common/netjack_packet.c

   1
   2 /*
   3  * NetJack - Packet Handling functions
   4  *
   5  * used by the driver and the jacknet_client
   6  *
   7  * Copyright (C) 2008 Marc-Olivier Barre <marco@marcochapeau.org>
   8  * Copyright (C) 2008 Pieter Palmers <pieterpalmers@users.sourceforge.net>
   9  * Copyright (C) 2006 Torben Hohn <torbenh@gmx.de>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  *
  25  * $Id: net_driver.c,v 1.16 2006/03/20 19:41:37 torbenh Exp $
  26  *
  27  */
  28
  29 //#include "config.h"
  30
  31 #define _XOPEN_SOURCE 600
  32 #define _BSD_SOURCE
  33
  34 #ifdef __APPLE__
  35 #define _DARWIN_C_SOURCE
  36 #endif
  37
  38 #if HAVE_PPOLL
  39 #define _GNU_SOURCE
  40 #endif
  41
  42 #include <math.h>
  43 #include <stdio.h>
  44 #include <memory.h>
  45 #include <unistd.h>
  46 #include <stdlib.h>
  47 #include <alloca.h>
  48 #include <errno.h>
  49 #include <stdarg.h>
  50
  51 #include <jack/types.h>
  52
  53 #include <sys/types.h>
  54
  55 #ifdef WIN32
  56 #include <winsock2.h>
  57 #include <malloc.h>
  58 #else
  59 #include <sys/socket.h>
  60 #include <netinet/in.h>
  61 #include <poll.h>
  62 #endif
  63
  64 #include <errno.h>
  65 #include <signal.h>
  66
  67 #if HAVE_SAMPLERATE
  68 #include <samplerate.h>
  69 #endif
  70
  71 #if HAVE_CELT
  72 #include <celt/celt.h>
  73 #endif
  74
  75 #include "netjack_packet.h"
  76
  77 // JACK2 specific.
  78 #include "jack/control.h"
  79
  80 #ifdef NO_JACK_ERROR
  81 #define jack_error printf
  82 #endif
  83
  84 int fraggo = 0;
  85
  86 packet_cache *global_packcache = NULL;
  87
  88 void
  89 packet_header_hton (jacknet_packet_header *pkthdr)
  90 {
  91     pkthdr->capture_channels_audio = htonl(pkthdr->capture_channels_audio);
  92     pkthdr->playback_channels_audio = htonl(pkthdr->playback_channels_audio);
  93     pkthdr->capture_channels_midi = htonl(pkthdr->capture_channels_midi);
  94     pkthdr->playback_channels_midi = htonl(pkthdr->playback_channels_midi);
  95     pkthdr->period_size = htonl(pkthdr->period_size);
  96     pkthdr->sample_rate = htonl(pkthdr->sample_rate);
  97     pkthdr->sync_state = htonl(pkthdr->sync_state);
  98     pkthdr->transport_frame = htonl(pkthdr->transport_frame);
  99     pkthdr->transport_state = htonl(pkthdr->transport_state);
 100     pkthdr->framecnt = htonl(pkthdr->framecnt);
 101     pkthdr->latency = htonl(pkthdr->latency);
 102     pkthdr->reply_port = htonl(pkthdr->reply_port);
 103     pkthdr->mtu = htonl(pkthdr->mtu);
 104     pkthdr->fragment_nr = htonl(pkthdr->fragment_nr);
 105 }
 106
 107 void
 108 packet_header_ntoh (jacknet_packet_header *pkthdr)
 109 {
 110     pkthdr->capture_channels_audio = ntohl(pkthdr->capture_channels_audio);
 111     pkthdr->playback_channels_audio = ntohl(pkthdr->playback_channels_audio);
 112     pkthdr->capture_channels_midi = ntohl(pkthdr->capture_channels_midi);
 113     pkthdr->playback_channels_midi = ntohl(pkthdr->playback_channels_midi);
 114     pkthdr->period_size = ntohl(pkthdr->period_size);
 115     pkthdr->sample_rate = ntohl(pkthdr->sample_rate);
 116     pkthdr->sync_state = ntohl(pkthdr->sync_state);
 117     pkthdr->transport_frame = ntohl(pkthdr->transport_frame);
 118     pkthdr->transport_state = ntohl(pkthdr->transport_state);
 119     pkthdr->framecnt = ntohl(pkthdr->framecnt);
 120     pkthdr->latency = ntohl(pkthdr->latency);
 121     pkthdr->reply_port = ntohl(pkthdr->reply_port);
 122     pkthdr->mtu = ntohl(pkthdr->mtu);
 123     pkthdr->fragment_nr = ntohl(pkthdr->fragment_nr);
 124 }
 125
 126 int get_sample_size (int bitdepth)
 127 {
 128     if (bitdepth == 8)
 129         return sizeof (int8_t);
 130     if (bitdepth == 16)
 131         return sizeof (int16_t);
 132     //JN: why? is this for buffer sizes before or after encoding?
 133     //JN: if the former, why not int16_t, if the latter, shouldn't it depend on -c N?
 134     if( bitdepth == CELT_MODE )
 135         return sizeof( unsigned char );
 136     return sizeof (int32_t);
 137 }
 138
 139 int jack_port_is_audio(const char *porttype)
 140 {
 141     return (strncmp (porttype, JACK_DEFAULT_AUDIO_TYPE, jack_port_type_size()) == 0);
 142 }
 143
 144 int jack_port_is_midi(const char *porttype)
 145 {
 146     return (strncmp (porttype, JACK_DEFAULT_MIDI_TYPE, jack_port_type_size()) == 0);
 147 }
 148
 149
 150 // fragment management functions.
 151
 152 packet_cache
 153 *packet_cache_new (int num_packets, int pkt_size, int mtu)
 154 {
 155     int fragment_payload_size = mtu - sizeof (jacknet_packet_header);
 156     int i, fragment_number;
 157
 158     if( pkt_size == sizeof(jacknet_packet_header) )
 159             fragment_number = 1;
 160     else
 161             fragment_number = (pkt_size - sizeof (jacknet_packet_header) - 1) / fragment_payload_size + 1;
 162
 163     packet_cache *pcache = malloc (sizeof (packet_cache));
 164     if (pcache == NULL)
 165     {
 166         jack_error ("could not allocate packet cache (1)\n");
 167         return NULL;
 168     }
 169
 170     pcache->size = num_packets;
 171     pcache->packets = malloc (sizeof (cache_packet) * num_packets);
 172     pcache->master_address_valid = 0;
 173     pcache->last_framecnt_retreived = 0;
 174     pcache->last_framecnt_retreived_valid = 0;
 175
 176     if (pcache->packets == NULL)
 177     {
 178         jack_error ("could not allocate packet cache (2)\n");
 179         return NULL;
 180     }
 181
 182     for (i = 0; i < num_packets; i++)
 183     {
 184         pcache->packets[i].valid = 0;
 185         pcache->packets[i].num_fragments = fragment_number;
 186         pcache->packets[i].packet_size = pkt_size;
 187         pcache->packets[i].mtu = mtu;
 188         pcache->packets[i].framecnt = 0;
 189         pcache->packets[i].fragment_array = malloc (sizeof (char) * fragment_number);
 190         pcache->packets[i].packet_buf = malloc (pkt_size);
 191         if ((pcache->packets[i].fragment_array == NULL) || (pcache->packets[i].packet_buf == NULL))
 192         {
 193             jack_error ("could not allocate packet cache (3)\n");
 194             return NULL;
 195         }
 196     }
 197     pcache->mtu = mtu;
 198
 199     return pcache;
 200 }
 201
 202 void
 203 packet_cache_free (packet_cache *pcache)
 204 {
 205     int i;
 206     if( pcache == NULL )
 207         return;
 208
 209     for (i = 0; i < pcache->size; i++)
 210     {
 211         free (pcache->packets[i].fragment_array);
 212         free (pcache->packets[i].packet_buf);
 213     }
 214
 215     free (pcache->packets);
 216     free (pcache);
 217 }
 218
 219 cache_packet
 220 *packet_cache_get_packet (packet_cache *pcache, jack_nframes_t framecnt)
 221 {
 222     int i;
 223     cache_packet *retval;
 224
 225     for (i = 0; i < pcache->size; i++)
 226     {
 227         if (pcache->packets[i].valid && (pcache->packets[i].framecnt == framecnt))
 228             return &(pcache->packets[i]);
 229     }
 230
 231     // The Packet is not in the packet cache.
 232     // find a free packet.
 233
 234     retval = packet_cache_get_free_packet (pcache);
 235     if (retval != NULL)
 236     {
 237         cache_packet_set_framecnt (retval, framecnt);
 238         return retval;
 239     }
 240
 241     // No Free Packet available
 242     // Get The Oldest packet and reset it.
 243
 244     retval = packet_cache_get_oldest_packet (pcache);
 245     //printf( "Dropping %d from Cache :S\n", retval->framecnt );
 246     cache_packet_reset (retval);
 247     cache_packet_set_framecnt (retval, framecnt);
 248
 249     return retval;
 250 }
 251
 252 // TODO: fix wrapping case... need to pass
 253 //       current expected frame here.
 254 //
 255 //       or just save framecount into packet_cache.
 256
 257 cache_packet
 258 *packet_cache_get_oldest_packet (packet_cache *pcache)
 259 {
 260     jack_nframes_t minimal_frame = JACK_MAX_FRAMES;
 261     cache_packet *retval = &(pcache->packets[0]);
 262     int i;
 263
 264     for (i = 0; i < pcache->size; i++)
 265     {
 266         if (pcache->packets[i].valid && (pcache->packets[i].framecnt < minimal_frame))
 267         {
 268             minimal_frame = pcache->packets[i].framecnt;
 269             retval = &(pcache->packets[i]);
 270         }
 271     }
 272
 273     return retval;
 274 }
 275
 276 cache_packet
 277 *packet_cache_get_free_packet (packet_cache *pcache)
 278 {
 279     int i;
 280
 281     for (i = 0; i < pcache->size; i++)
 282     {
 283         if (pcache->packets[i].valid == 0)
 284             return &(pcache->packets[i]);
 285     }
 286
 287     return NULL;
 288 }
 289
 290 void
 291 cache_packet_reset (cache_packet *pack)
 292 {
 293     int i;
 294     pack->valid = 0;
 295
 296     // XXX: i dont think this is necessary here...
 297     //      fragement array is cleared in _set_framecnt()
 298
 299     for (i = 0; i < pack->num_fragments; i++)
 300         pack->fragment_array[i] = 0;
 301 }
 302
 303 void
 304 cache_packet_set_framecnt (cache_packet *pack, jack_nframes_t framecnt)
 305 {
 306     int i;
 307
 308     pack->framecnt = framecnt;
 309
 310     for (i = 0; i < pack->num_fragments; i++)
 311         pack->fragment_array[i] = 0;
 312
 313     pack->valid = 1;
 314 }
 315
 316 void
 317 cache_packet_add_fragment (cache_packet *pack, char *packet_buf, int rcv_len)
 318 {
 319     jacknet_packet_header *pkthdr = (jacknet_packet_header *) packet_buf;
 320     int fragment_payload_size = pack->mtu - sizeof (jacknet_packet_header);
 321     char *packet_bufX = pack->packet_buf + sizeof (jacknet_packet_header);
 322     char *dataX = packet_buf + sizeof (jacknet_packet_header);
 323
 324     jack_nframes_t fragment_nr = ntohl (pkthdr->fragment_nr);
 325     jack_nframes_t framecnt    = ntohl (pkthdr->framecnt);
 326
 327     if (framecnt != pack->framecnt)
 328     {
 329         jack_error ("errror. framecnts dont match\n");
 330         return;
 331     }
 332
 333
 334     if (fragment_nr == 0)
 335     {
 336         memcpy (pack->packet_buf, packet_buf, rcv_len);
 337         pack->fragment_array[0] = 1;
 338
 339         return;
 340     }
 341
 342     if ((fragment_nr < pack->num_fragments) && (fragment_nr > 0))
 343     {
 344         if ((fragment_nr * fragment_payload_size + rcv_len - sizeof (jacknet_packet_header)) <= (pack->packet_size - sizeof (jacknet_packet_header)))
 345         {
 346             memcpy (packet_bufX + fragment_nr * fragment_payload_size, dataX, rcv_len - sizeof (jacknet_packet_header));
 347             pack->fragment_array[fragment_nr] = 1;
 348         }
 349         else
 350             jack_error ("too long packet received...");
 351     }
 352 }
 353
 354 int
 355 cache_packet_is_complete (cache_packet *pack)
 356 {
 357     int i;
 358     for (i = 0; i < pack->num_fragments; i++)
 359         if (pack->fragment_array[i] == 0)
 360             return 0;
 361
 362     return 1;
 363 }
 364
 365 #ifndef WIN32
 366 // new poll using nanoseconds resolution and
 367 // not waiting forever.
 368 int
 369 netjack_poll_deadline (int sockfd, jack_time_t deadline)
 370 {
 371     struct pollfd fds;
 372     int i, poll_err = 0;
 373     sigset_t sigmask;
 374     struct sigaction action;
 375 #if HAVE_PPOLL
 376     struct timespec timeout_spec = { 0, 0 };
 377 #else
 378     sigset_t rsigmask;
 379     int timeout;
 380 #endif
 381
 382
 383     jack_time_t now = jack_get_time();
 384     if( now >= deadline )
 385         return 0;
 386
 387     if( (deadline-now) >= 1000000 ) {
 388             jack_error( "deadline more than 1 second in the future, trimming it." );
 389             deadline = now+500000;
 390     }
 391 #if HAVE_PPOLL
 392     timeout_spec.tv_nsec = (deadline - now) * 1000;
 393 #else
 394     timeout = lrintf( (float)(deadline - now) / 1000.0 );
 395 #endif
 396
 397     sigemptyset(&sigmask);
 398         sigaddset(&sigmask, SIGHUP);
 399         sigaddset(&sigmask, SIGINT);
 400         sigaddset(&sigmask, SIGQUIT);
 401         sigaddset(&sigmask, SIGPIPE);
 402         sigaddset(&sigmask, SIGTERM);
 403         sigaddset(&sigmask, SIGUSR1);
 404         sigaddset(&sigmask, SIGUSR2);
 405
 406         action.sa_handler = SIG_DFL;
 407         action.sa_mask = sigmask;
 408         action.sa_flags = SA_RESTART;
 409
 410     for (i = 1; i < NSIG; i++)
 411         if (sigismember (&sigmask, i))
 412             sigaction (i, &action, 0);
 413
 414     fds.fd = sockfd;
 415     fds.events = POLLIN;
 416
 417 #if HAVE_PPOLL
 418     poll_err = ppoll (&fds, 1, &timeout_spec, &sigmask);
 419 #else
 420     sigprocmask (SIG_UNBLOCK, &sigmask, &rsigmask);
 421     poll_err = poll (&fds, 1, timeout);
 422     sigprocmask (SIG_SETMASK, &rsigmask, NULL);
 423 #endif
 424
 425     if (poll_err == -1)
 426     {
 427         switch (errno)
 428         {
 429             case EBADF:
 430             jack_error ("Error %d: An invalid file descriptor was given in one of the sets", errno);
 431             break;
 432             case EFAULT:
 433             jack_error ("Error %d: The array given as argument was not contained in the calling program's address space", errno);
 434             break;
 435             case EINTR:
 436             jack_error ("Error %d: A signal occurred before any requested event", errno);
 437             break;
 438             case EINVAL:
 439             jack_error ("Error %d: The nfds value exceeds the RLIMIT_NOFILE value", errno);
 440             break;
 441             case ENOMEM:
 442             jack_error ("Error %d: There was no space to allocate file descriptor tables", errno);
 443             break;
 444         }
 445     }
 446     return poll_err;
 447 }
 448
 449 int
 450 netjack_poll (int sockfd, int timeout)
 451 {
 452     struct pollfd fds;
 453     int i, poll_err = 0;
 454     sigset_t sigmask, rsigmask;
 455     struct sigaction action;
 456
 457     sigemptyset(&sigmask);
 458         sigaddset(&sigmask, SIGHUP);
 459         sigaddset(&sigmask, SIGINT);
 460         sigaddset(&sigmask, SIGQUIT);
 461         sigaddset(&sigmask, SIGPIPE);
 462         sigaddset(&sigmask, SIGTERM);
 463         sigaddset(&sigmask, SIGUSR1);
 464         sigaddset(&sigmask, SIGUSR2);
 465
 466         action.sa_handler = SIG_DFL;
 467         action.sa_mask = sigmask;
 468         action.sa_flags = SA_RESTART;
 469
 470     for (i = 1; i < NSIG; i++)
 471         if (sigismember (&sigmask, i))
 472             sigaction (i, &action, 0);
 473
 474     fds.fd = sockfd;
 475     fds.events = POLLIN;
 476
 477     sigprocmask(SIG_UNBLOCK, &sigmask, &rsigmask);
 478     while (poll_err == 0)
 479     {
 480         poll_err = poll (&fds, 1, timeout);
 481     }
 482     sigprocmask(SIG_SETMASK, &rsigmask, NULL);
 483
 484     if (poll_err == -1)
 485     {
 486         switch (errno)
 487         {
 488             case EBADF:
 489             jack_error ("Error %d: An invalid file descriptor was given in one of the sets", errno);
 490             break;
 491             case EFAULT:
 492             jack_error ("Error %d: The array given as argument was not contained in the calling program's address space", errno);
 493             break;
 494             case EINTR:
 495             jack_error ("Error %d: A signal occurred before any requested event", errno);
 496             break;
 497             case EINVAL:
 498             jack_error ("Error %d: The nfds value exceeds the RLIMIT_NOFILE value", errno);
 499             break;
 500             case ENOMEM:
 501             jack_error ("Error %d: There was no space to allocate file descriptor tables", errno);
 502             break;
 503         }
 504         return 0;
 505     }
 506     return 1;
 507 }
 508
 509 #else
 510 int
 511 netjack_poll (int sockfd, int timeout)
 512 {
 513     jack_error( "netjack_poll not implemented\n" );
 514     return 0;
 515 }
 516 int
 517 netjack_poll_deadline (int sockfd, jack_time_t deadline)
 518 {
 519     fd_set fds;
 520     FD_ZERO( &fds );
 521     FD_SET( sockfd, &fds );
 522
 523     struct timeval timeout;
 524     while( 1 ) {
 525         jack_time_t now = jack_get_time();
 526         if( now >= deadline )
 527                 return 0;
 528
 529         int timeout_usecs = (deadline - now);
 530     //jack_error( "timeout = %d", timeout_usecs );
 531         timeout.tv_sec = 0;
 532         timeout.tv_usec = (timeout_usecs < 500) ? 500 : timeout_usecs;
 533         timeout.tv_usec = (timeout_usecs > 1000000) ? 500000 : timeout_usecs;
 534
 535         int poll_err = select (0, &fds, NULL, NULL, &timeout);
 536         if( poll_err != 0 )
 537             return poll_err;
 538     }
 539
 540     return 0;
 541 }
 542 #endif
 543 // This now reads all a socket has into the cache.
 544 // replacing netjack_recv functions.
 545
 546 void
 547 packet_cache_drain_socket( packet_cache *pcache, int sockfd )
 548 {
 549     char *rx_packet = alloca (pcache->mtu);
 550     jacknet_packet_header *pkthdr = (jacknet_packet_header *) rx_packet;
 551     int rcv_len;
 552     jack_nframes_t framecnt;
 553     cache_packet *cpack;
 554     struct sockaddr_in sender_address;
 555 #ifdef WIN32
 556     size_t senderlen = sizeof( struct sockaddr_in );
 557     u_long parm = 1;
 558     ioctlsocket( sockfd, FIONBIO, &parm );
 559 #else
 560     socklen_t senderlen = sizeof( struct sockaddr_in );
 561 #endif
 562     while (1)
 563     {
 564 #ifdef WIN32
 565         rcv_len = recvfrom (sockfd, rx_packet, pcache->mtu, 0,
 566                             (struct sockaddr*) &sender_address, &senderlen);
 567 #else
 568         rcv_len = recvfrom (sockfd, rx_packet, pcache->mtu, MSG_DONTWAIT,
 569                             (struct sockaddr*) &sender_address, &senderlen);
 570 #endif
 571         if (rcv_len < 0)
 572             return;
 573
 574         if (pcache->master_address_valid) {
 575             // Verify its from our master.
 576             if (memcmp (&sender_address, &(pcache->master_address), senderlen) != 0)
 577                 continue;
 578         } else {
 579             // Setup this one as master
 580             //printf( "setup master...\n" );
 581             memcpy ( &(pcache->master_address), &sender_address, senderlen );
 582             pcache->master_address_valid = 1;
 583         }
 584
 585         framecnt = ntohl (pkthdr->framecnt);
 586         if( pcache->last_framecnt_retreived_valid && (framecnt <= pcache->last_framecnt_retreived ))
 587             continue;
 588
 589         cpack = packet_cache_get_packet (global_packcache, framecnt);
 590         cache_packet_add_fragment (cpack, rx_packet, rcv_len);
 591         cpack->recv_timestamp = jack_get_time();
 592     }
 593 }
 594
 595 void
 596 packet_cache_reset_master_address( packet_cache *pcache )
 597 {
 598     pcache->master_address_valid = 0;
 599     pcache->last_framecnt_retreived = 0;
 600     pcache->last_framecnt_retreived_valid = 0;
 601 }
 602
 603 void
 604 packet_cache_clear_old_packets (packet_cache *pcache, jack_nframes_t framecnt )
 605 {
 606     int i;
 607
 608     for (i = 0; i < pcache->size; i++)
 609     {
 610         if (pcache->packets[i].valid && (pcache->packets[i].framecnt < framecnt))
 611         {
 612             cache_packet_reset (&(pcache->packets[i]));
 613         }
 614     }
 615 }
 616
 617 int
 618 packet_cache_retreive_packet_pointer( packet_cache *pcache, jack_nframes_t framecnt, char **packet_buf, int pkt_size, jack_time_t *timestamp )
 619 {
 620     int i;
 621     cache_packet *cpack = NULL;
 622
 623
 624     for (i = 0; i < pcache->size; i++) {
 625         if (pcache->packets[i].valid && (pcache->packets[i].framecnt == framecnt)) {
 626             cpack = &(pcache->packets[i]);
 627             break;
 628         }
 629     }
 630
 631     if( cpack == NULL ) {
 632         //printf( "retreive packet: %d....not found\n", framecnt );
 633         return -1;
 634     }
 635
 636     if( !cache_packet_is_complete( cpack ) ) {
 637         return -1;
 638     }
 639
 640     // ok. cpack is the one we want and its complete.
 641     *packet_buf = cpack->packet_buf;
 642     if( timestamp )
 643         *timestamp = cpack->recv_timestamp;
 644
 645     pcache->last_framecnt_retreived_valid = 1;
 646     pcache->last_framecnt_retreived = framecnt;
 647
 648     return pkt_size;
 649 }
 650
 651 int
 652 packet_cache_release_packet( packet_cache *pcache, jack_nframes_t framecnt )
 653 {
 654     int i;
 655     cache_packet *cpack = NULL;
 656
 657
 658     for (i = 0; i < pcache->size; i++) {
 659         if (pcache->packets[i].valid && (pcache->packets[i].framecnt == framecnt)) {
 660             cpack = &(pcache->packets[i]);
 661             break;
 662         }
 663     }
 664
 665     if( cpack == NULL ) {
 666         //printf( "retreive packet: %d....not found\n", framecnt );
 667         return -1;
 668     }
 669
 670     if( !cache_packet_is_complete( cpack ) ) {
 671         return -1;
 672     }
 673
 674     cache_packet_reset (cpack);
 675     packet_cache_clear_old_packets( pcache, framecnt );
 676
 677     return 0;
 678 }
 679 float
 680 packet_cache_get_fill( packet_cache *pcache, jack_nframes_t expected_framecnt )
 681 {
 682     int num_packets_before_us = 0;
 683     int i;
 684
 685     for (i = 0; i < pcache->size; i++)
 686     {
 687         cache_packet *cpack = &(pcache->packets[i]);
 688         if (cpack->valid && cache_packet_is_complete( cpack ))
 689             if( cpack->framecnt >= expected_framecnt )
 690                 num_packets_before_us += 1;
 691     }
 692
 693     return 100.0 * (float)num_packets_before_us / (float)( pcache->size ) ;
 694 }
 695
 696 // Returns 0 when no valid packet is inside the cache.
 697 int
 698 packet_cache_get_next_available_framecnt( packet_cache *pcache, jack_nframes_t expected_framecnt, jack_nframes_t *framecnt )
 699 {
 700     int i;
 701     jack_nframes_t best_offset = JACK_MAX_FRAMES/2-1;
 702     int retval = 0;
 703
 704     for (i = 0; i < pcache->size; i++)
 705     {
 706         cache_packet *cpack = &(pcache->packets[i]);
 707         //printf( "p%d: valid=%d, frame %d\n", i, cpack->valid, cpack->framecnt );
 708
 709         if (!cpack->valid || !cache_packet_is_complete( cpack )) {
 710             //printf( "invalid\n" );
 711             continue;
 712         }
 713
 714         if( cpack->framecnt < expected_framecnt )
 715             continue;
 716
 717         if( (cpack->framecnt - expected_framecnt) > best_offset ) {
 718             continue;
 719         }
 720
 721         best_offset = cpack->framecnt - expected_framecnt;
 722         retval = 1;
 723
 724         if( best_offset == 0 )
 725             break;
 726     }
 727     if( retval && framecnt )
 728         *framecnt = expected_framecnt + best_offset;
 729
 730     return retval;
 731 }
 732
 733 int
 734 packet_cache_get_highest_available_framecnt( packet_cache *pcache, jack_nframes_t *framecnt )
 735 {
 736     int i;
 737     jack_nframes_t best_value = 0;
 738     int retval = 0;
 739
 740     for (i = 0; i < pcache->size; i++)
 741     {
 742         cache_packet *cpack = &(pcache->packets[i]);
 743         //printf( "p%d: valid=%d, frame %d\n", i, cpack->valid, cpack->framecnt );
 744
 745         if (!cpack->valid || !cache_packet_is_complete( cpack )) {
 746             //printf( "invalid\n" );
 747             continue;
 748         }
 749
 750         if (cpack->framecnt < best_value) {
 751             continue;
 752         }
 753
 754         best_value = cpack->framecnt;
 755         retval = 1;
 756
 757     }
 758     if( retval && framecnt )
 759         *framecnt = best_value;
 760
 761     return retval;
 762 }
 763
 764 // Returns 0 when no valid packet is inside the cache.
 765 int
 766 packet_cache_find_latency( packet_cache *pcache, jack_nframes_t expected_framecnt, jack_nframes_t *framecnt )
 767 {
 768     int i;
 769     jack_nframes_t best_offset = 0;
 770     int retval = 0;
 771
 772     for (i = 0; i < pcache->size; i++)
 773     {
 774         cache_packet *cpack = &(pcache->packets[i]);
 775         //printf( "p%d: valid=%d, frame %d\n", i, cpack->valid, cpack->framecnt );
 776
 777         if (!cpack->valid || !cache_packet_is_complete( cpack )) {
 778             //printf( "invalid\n" );
 779             continue;
 780         }
 781
 782         if( (cpack->framecnt - expected_framecnt) < best_offset ) {
 783             continue;
 784         }
 785
 786         best_offset = cpack->framecnt - expected_framecnt;
 787         retval = 1;
 788
 789         if( best_offset == 0 )
 790             break;
 791     }
 792     if( retval && framecnt )
 793         *framecnt = JACK_MAX_FRAMES - best_offset;
 794
 795     return retval;
 796 }
 797 // fragmented packet IO
 798 int
 799 netjack_recvfrom (int sockfd, char *packet_buf, int pkt_size, int flags, struct sockaddr *addr, size_t *addr_size, int mtu)
 800 {
 801     int retval;
 802     socklen_t from_len = *addr_size;
 803     if (pkt_size <= mtu) {
 804         retval = recvfrom (sockfd, packet_buf, pkt_size, flags, addr, &from_len);
 805         *addr_size = from_len;
 806         return retval;
 807     }
 808
 809     char *rx_packet = alloca (mtu);
 810     jacknet_packet_header *pkthdr = (jacknet_packet_header *) rx_packet;
 811     int rcv_len;
 812     jack_nframes_t framecnt;
 813     cache_packet *cpack;
 814     do
 815     {
 816         rcv_len = recvfrom (sockfd, rx_packet, mtu, 0, addr, &from_len);
 817         if (rcv_len < 0)
 818             return rcv_len;
 819         framecnt = ntohl (pkthdr->framecnt);
 820         cpack = packet_cache_get_packet (global_packcache, framecnt);
 821         cache_packet_add_fragment (cpack, rx_packet, rcv_len);
 822     } while (!cache_packet_is_complete (cpack));
 823     memcpy (packet_buf, cpack->packet_buf, pkt_size);
 824     cache_packet_reset (cpack);
 825     *addr_size = from_len;
 826     return pkt_size;
 827 }
 828
 829 int
 830 netjack_recv (int sockfd, char *packet_buf, int pkt_size, int flags, int mtu)
 831 {
 832     if (pkt_size <= mtu)
 833         return recv (sockfd, packet_buf, pkt_size, flags);
 834     char *rx_packet = alloca (mtu);
 835     jacknet_packet_header *pkthdr = (jacknet_packet_header *) rx_packet;
 836     int rcv_len;
 837     jack_nframes_t framecnt;
 838     cache_packet *cpack;
 839     do
 840     {
 841         rcv_len = recv (sockfd, rx_packet, mtu, flags);
 842         if (rcv_len < 0)
 843             return rcv_len;
 844         framecnt = ntohl (pkthdr->framecnt);
 845         cpack = packet_cache_get_packet (global_packcache, framecnt);
 846         cache_packet_add_fragment (cpack, rx_packet, rcv_len);
 847     } while (!cache_packet_is_complete (cpack));
 848     memcpy (packet_buf, cpack->packet_buf, pkt_size);
 849     cache_packet_reset (cpack);
 850     return pkt_size;
 851 }
 852
 853 void
 854 netjack_sendto (int sockfd, char *packet_buf, int pkt_size, int flags, struct sockaddr *addr, int addr_size, int mtu)
 855 {
 856     int frag_cnt = 0;
 857     char *tx_packet, *dataX;
 858     jacknet_packet_header *pkthdr;
 859
 860     tx_packet = alloca (mtu + 10);
 861     dataX = tx_packet + sizeof (jacknet_packet_header);
 862     pkthdr = (jacknet_packet_header *) tx_packet;
 863
 864     int fragment_payload_size = mtu - sizeof (jacknet_packet_header);
 865
 866     if (pkt_size <= mtu) {
 867         int err;
 868         pkthdr = (jacknet_packet_header *) packet_buf;
 869         pkthdr->fragment_nr = htonl (0);
 870         err = sendto(sockfd, packet_buf, pkt_size, flags, addr, addr_size);
 871         if( err<0 ) {
 872             //printf( "error in send\n" );
 873             perror( "send" );
 874         }
 875     }
 876     else
 877     {
 878         int err;
 879         // Copy the packet header to the tx pack first.
 880         memcpy(tx_packet, packet_buf, sizeof (jacknet_packet_header));
 881
 882         // Now loop and send all
 883         char *packet_bufX = packet_buf + sizeof (jacknet_packet_header);
 884
 885         while (packet_bufX < (packet_buf + pkt_size - fragment_payload_size))
 886         {
 887             pkthdr->fragment_nr = htonl (frag_cnt++);
 888             memcpy (dataX, packet_bufX, fragment_payload_size);
 889             sendto (sockfd, tx_packet, mtu, flags, addr, addr_size);
 890             packet_bufX += fragment_payload_size;
 891         }
 892
 893         int last_payload_size = packet_buf + pkt_size - packet_bufX;
 894         memcpy (dataX, packet_bufX, last_payload_size);
 895         pkthdr->fragment_nr = htonl (frag_cnt);
 896         //jack_log("last fragment_count = %d, payload_size = %d\n", fragment_count, last_payload_size);
 897
 898         // sendto(last_pack_size);
 899         err = sendto(sockfd, tx_packet, last_payload_size + sizeof(jacknet_packet_header), flags, addr, addr_size);
 900         if( err<0 ) {
 901             //printf( "error in send\n" );
 902             perror( "send" );
 903         }
 904     }
 905 }
 906
 907
 908 void
 909 decode_midi_buffer (uint32_t *buffer_uint32, unsigned int buffer_size_uint32, jack_default_audio_sample_t* buf)
 910 {
 911     int i;
 912     jack_midi_clear_buffer (buf);
 913     for (i = 0; i < buffer_size_uint32 - 3;)
 914     {
 915         uint32_t payload_size;
 916         payload_size = buffer_uint32[i];
 917         payload_size = ntohl (payload_size);
 918         if (payload_size)
 919         {
 920             jack_midi_event_t event;
 921             event.time = ntohl (buffer_uint32[i+1]);
 922             event.size = ntohl (buffer_uint32[i+2]);
 923             event.buffer = (jack_midi_data_t*) (&(buffer_uint32[i+3]));
 924             jack_midi_event_write (buf, event.time, event.buffer, event.size);
 925
 926             // skip to the next event
 927             unsigned int nb_data_quads = (((event.size-1) & ~0x3) >> 2)+1;
 928             i += 3+nb_data_quads;
 929         }
 930         else
 931             break; // no events can follow an empty event, we're done
 932     }
 933 }
 934
 935 void
 936 encode_midi_buffer (uint32_t *buffer_uint32, unsigned int buffer_size_uint32, jack_default_audio_sample_t* buf)
 937 {
 938     int i;
 939     unsigned int written = 0;
 940     // midi port, encode midi events
 941     unsigned int nevents = jack_midi_get_event_count (buf);
 942     for (i = 0; i < nevents; ++i)
 943     {
 944         jack_midi_event_t event;
 945         jack_midi_event_get (&event, buf, i);
 946         unsigned int nb_data_quads = (((event.size - 1) & ~0x3) >> 2) + 1;
 947         unsigned int payload_size = 3 + nb_data_quads;
 948         // only write if we have sufficient space for the event
 949         // otherwise drop it
 950         if (written + payload_size < buffer_size_uint32 - 1)
 951         {
 952             // write header
 953             buffer_uint32[written]=htonl (payload_size);
 954             written++;
 955             buffer_uint32[written]=htonl (event.time);
 956             written++;
 957             buffer_uint32[written]=htonl (event.size);
 958             written++;
 959
 960             // write data
 961             jack_midi_data_t* tmpbuff = (jack_midi_data_t*)(&(buffer_uint32[written]));
 962             memcpy (tmpbuff, event.buffer, event.size);
 963             written += nb_data_quads;
 964         }
 965         else
 966         {
 967             // buffer overflow
 968             jack_error ("midi buffer overflow");
 969             break;
 970         }
 971     }
 972     // now put a netjack_midi 'no-payload' event, signaling EOF
 973     buffer_uint32[written]=0;
 974 }
 975
 976 // render functions for float
 977 void
 978 render_payload_to_jack_ports_float ( void *packet_payload, jack_nframes_t net_period_down, JSList *capture_ports, JSList *capture_srcs, jack_nframes_t nframes, int dont_htonl_floats)
 979 {
 980     int chn = 0;
 981     JSList *node = capture_ports;
 982 #if HAVE_SAMPLERATE
 983     JSList *src_node = capture_srcs;
 984 #endif
 985
 986     uint32_t *packet_bufX = (uint32_t *)packet_payload;
 987
 988     if( !packet_payload )
 989         return;
 990
 991     while (node != NULL)
 992     {
 993         int i;
 994         int_float_t val;
 995 #if HAVE_SAMPLERATE
 996         SRC_DATA src;
 997 #endif
 998
 999         jack_port_t *port = (jack_port_t *) node->data;
1000         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
1001
1002         const char *porttype = jack_port_type (port);
1003
1004         if (jack_port_is_audio (porttype))
1005         {
1006 #if HAVE_SAMPLERATE
1007             // audio port, resample if necessary
1008             if (net_period_down != nframes)
1009             {
1010                 SRC_STATE *src_state = src_node->data;
1011                 for (i = 0; i < net_period_down; i++)
1012                 {
1013                     packet_bufX[i] = ntohl (packet_bufX[i]);
1014                 }
1015
1016                 src.data_in = (float *) packet_bufX;
1017                 src.input_frames = net_period_down;
1018
1019                 src.data_out = buf;
1020                 src.output_frames = nframes;
1021
1022                 src.src_ratio = (float) nframes / (float) net_period_down;
1023                 src.end_of_input = 0;
1024
1025                 src_set_ratio (src_state, src.src_ratio);
1026                 src_process (src_state, &src);
1027                 src_node = jack_slist_next (src_node);
1028             }
1029             else
1030 #endif
1031             {
1032                 if( dont_htonl_floats )
1033                 {
1034                     memcpy( buf, packet_bufX, net_period_down*sizeof(jack_default_audio_sample_t));
1035                 }
1036                 else
1037                 {
1038                     for (i = 0; i < net_period_down; i++)
1039                     {
1040                         val.i = packet_bufX[i];
1041                         val.i = ntohl (val.i);
1042                         buf[i] = val.f;
1043                     }
1044                 }
1045             }
1046         }
1047         else if (jack_port_is_midi (porttype))
1048         {
1049             // midi port, decode midi events
1050             // convert the data buffer to a standard format (uint32_t based)
1051             unsigned int buffer_size_uint32 = net_period_down;
1052             uint32_t * buffer_uint32 = (uint32_t*)packet_bufX;
1053             decode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
1054         }
1055         packet_bufX = (packet_bufX + net_period_down);
1056         node = jack_slist_next (node);
1057         chn++;
1058     }
1059 }
1060
1061 void
1062 render_jack_ports_to_payload_float (JSList *playback_ports, JSList *playback_srcs, jack_nframes_t nframes, void *packet_payload, jack_nframes_t net_period_up, int dont_htonl_floats )
1063 {
1064     int chn = 0;
1065     JSList *node = playback_ports;
1066 #if HAVE_SAMPLERATE
1067     JSList *src_node = playback_srcs;
1068 #endif
1069
1070     uint32_t *packet_bufX = (uint32_t *) packet_payload;
1071
1072     while (node != NULL)
1073     {
1074 #if HAVE_SAMPLERATE
1075         SRC_DATA src;
1076 #endif
1077         int i;
1078         int_float_t val;
1079         jack_port_t *port = (jack_port_t *) node->data;
1080         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
1081
1082         const char *porttype = jack_port_type (port);
1083
1084         if (jack_port_is_audio (porttype))
1085         {
1086             // audio port, resample if necessary
1087
1088 #if HAVE_SAMPLERATE
1089             if (net_period_up != nframes) {
1090                 SRC_STATE *src_state = src_node->data;
1091                 src.data_in = buf;
1092                 src.input_frames = nframes;
1093
1094                 src.data_out = (float *) packet_bufX;
1095                 src.output_frames = net_period_up;
1096
1097                 src.src_ratio = (float) net_period_up / (float) nframes;
1098                 src.end_of_input = 0;
1099
1100                 src_set_ratio (src_state, src.src_ratio);
1101                 src_process (src_state, &src);
1102
1103                 for (i = 0; i < net_period_up; i++)
1104                 {
1105                     packet_bufX[i] = htonl (packet_bufX[i]);
1106                 }
1107                 src_node = jack_slist_next (src_node);
1108             }
1109             else
1110 #endif
1111             {
1112                 if( dont_htonl_floats )
1113                 {
1114                     memcpy( packet_bufX, buf, net_period_up*sizeof(jack_default_audio_sample_t) );
1115                 }
1116                 else
1117                 {
1118                     for (i = 0; i < net_period_up; i++)
1119                     {
1120                         val.f = buf[i];
1121                         val.i = htonl (val.i);
1122                         packet_bufX[i] = val.i;
1123                     }
1124                 }
1125             }
1126         }
1127         else if (jack_port_is_midi (porttype))
1128         {
1129             // encode midi events from port to packet
1130             // convert the data buffer to a standard format (uint32_t based)
1131             unsigned int buffer_size_uint32 = net_period_up;
1132             uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;
1133             encode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
1134         }
1135         packet_bufX = (packet_bufX + net_period_up);
1136         node = jack_slist_next (node);
1137         chn++;
1138     }
1139 }
1140
1141 // render functions for 16bit
1142 void
1143 render_payload_to_jack_ports_16bit (void *packet_payload, jack_nframes_t net_period_down, JSList *capture_ports, JSList *capture_srcs, jack_nframes_t nframes)
1144 {
1145     int chn = 0;
1146     JSList *node = capture_ports;
1147 #if HAVE_SAMPLERATE
1148     JSList *src_node = capture_srcs;
1149 #endif
1150
1151     uint16_t *packet_bufX = (uint16_t *)packet_payload;
1152
1153     if( !packet_payload )
1154         return;
1155
1156     while (node != NULL)
1157     {
1158         int i;
1159         //uint32_t val;
1160 #if HAVE_SAMPLERATE
1161         SRC_DATA src;
1162 #endif
1163
1164         jack_port_t *port = (jack_port_t *) node->data;
1165         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
1166
1167 #if HAVE_SAMPLERATE
1168         float *floatbuf = alloca (sizeof(float) * net_period_down);
1169 #endif
1170         const char *porttype = jack_port_type (port);
1171
1172         if (jack_port_is_audio (porttype))
1173         {
1174             // audio port, resample if necessary
1175
1176 #if HAVE_SAMPLERATE
1177             if (net_period_down != nframes)
1178             {
1179                 SRC_STATE *src_state = src_node->data;
1180                 for (i = 0; i < net_period_down; i++)
1181                 {
1182                     floatbuf[i] = ((float) ntohs(packet_bufX[i])) / 32767.0 - 1.0;
1183                 }
1184
1185                 src.data_in = floatbuf;
1186                 src.input_frames = net_period_down;
1187
1188                 src.data_out = buf;
1189                 src.output_frames = nframes;
1190
1191                 src.src_ratio = (float) nframes / (float) net_period_down;
1192                 src.end_of_input = 0;
1193
1194                 src_set_ratio (src_state, src.src_ratio);
1195                 src_process (src_state, &src);
1196                 src_node = jack_slist_next (src_node);
1197             }
1198             else
1199 #endif
1200                 for (i = 0; i < net_period_down; i++)
1201                     buf[i] = ((float) ntohs (packet_bufX[i])) / 32768.0 - 1.0;
1202         }
1203         else if (jack_port_is_midi (porttype))
1204         {
1205             // midi port, decode midi events
1206             // convert the data buffer to a standard format (uint32_t based)
1207             unsigned int buffer_size_uint32 = net_period_down / 2;
1208             uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;
1209             decode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
1210         }
1211         packet_bufX = (packet_bufX + net_period_down);
1212         node = jack_slist_next (node);
1213         chn++;
1214     }
1215 }
1216
1217 void
1218 render_jack_ports_to_payload_16bit (JSList *playback_ports, JSList *playback_srcs, jack_nframes_t nframes, void *packet_payload, jack_nframes_t net_period_up)
1219 {
1220     int chn = 0;
1221     JSList *node = playback_ports;
1222 #if HAVE_SAMPLERATE
1223     JSList *src_node = playback_srcs;
1224 #endif
1225
1226     uint16_t *packet_bufX = (uint16_t *)packet_payload;
1227
1228     while (node != NULL)
1229     {
1230 #if HAVE_SAMPLERATE
1231         SRC_DATA src;
1232 #endif
1233         int i;
1234         jack_port_t *port = (jack_port_t *) node->data;
1235         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
1236         const char *porttype = jack_port_type (port);
1237
1238         if (jack_port_is_audio (porttype))
1239         {
1240             // audio port, resample if necessary
1241
1242 #if HAVE_SAMPLERATE
1243             if (net_period_up != nframes)
1244             {
1245                 SRC_STATE *src_state = src_node->data;
1246
1247                 float *floatbuf = alloca (sizeof(float) * net_period_up);
1248
1249                 src.data_in = buf;
1250                 src.input_frames = nframes;
1251
1252                 src.data_out = floatbuf;
1253                 src.output_frames = net_period_up;
1254
1255                 src.src_ratio = (float) net_period_up / (float) nframes;
1256                 src.end_of_input = 0;
1257
1258                 src_set_ratio (src_state, src.src_ratio);
1259                 src_process (src_state, &src);
1260
1261                 for (i = 0; i < net_period_up; i++)
1262                 {
1263                     packet_bufX[i] = htons (((uint16_t)((floatbuf[i] + 1.0) * 32767.0)));
1264                 }
1265                 src_node = jack_slist_next (src_node);
1266             }
1267             else
1268 #endif
1269                 for (i = 0; i < net_period_up; i++)
1270                     packet_bufX[i] = htons(((uint16_t)((buf[i] + 1.0) * 32767.0)));
1271         }
1272         else if (jack_port_is_midi (porttype))
1273         {
1274             // encode midi events from port to packet
1275             // convert the data buffer to a standard format (uint32_t based)
1276             unsigned int buffer_size_uint32 = net_period_up / 2;
1277             uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;
1278             encode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
1279         }
1280         packet_bufX = (packet_bufX + net_period_up);
1281         node = jack_slist_next (node);
1282         chn++;
1283     }
1284 }
1285
1286 // render functions for 8bit
1287 void
1288 render_payload_to_jack_ports_8bit (void *packet_payload, jack_nframes_t net_period_down, JSList *capture_ports, JSList *capture_srcs, jack_nframes_t nframes)
1289 {
1290     int chn = 0;
1291     JSList *node = capture_ports;
1292
1293 #if HAVE_SAMPLERATE
1294     JSList *src_node = capture_srcs;
1295 #endif
1296
1297     int8_t *packet_bufX = (int8_t *)packet_payload;
1298
1299     if( !packet_payload )
1300         return;
1301
1302     while (node != NULL)
1303     {
1304         int i;
1305         //uint32_t val;
1306 #if HAVE_SAMPLERATE
1307         SRC_DATA src;
1308 #endif
1309
1310         jack_port_t *port = (jack_port_t *) node->data;
1311         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
1312
1313 #if HAVE_SAMPLERATE
1314         float *floatbuf = alloca (sizeof (float) * net_period_down);
1315 #endif
1316         const char *porttype = jack_port_type (port);
1317
1318         if (jack_port_is_audio(porttype))
1319         {
1320 #if HAVE_SAMPLERATE
1321             // audio port, resample if necessary
1322             if (net_period_down != nframes)
1323             {
1324                 SRC_STATE *src_state = src_node->data;
1325                 for (i = 0; i < net_period_down; i++)
1326                     floatbuf[i] = ((float) packet_bufX[i]) / 127.0;
1327
1328                 src.data_in = floatbuf;
1329                 src.input_frames = net_period_down;
1330
1331                 src.data_out = buf;
1332                 src.output_frames = nframes;
1333
1334                 src.src_ratio = (float) nframes / (float) net_period_down;
1335                 src.end_of_input = 0;
1336
1337                 src_set_ratio (src_state, src.src_ratio);
1338                 src_process (src_state, &src);
1339                 src_node = jack_slist_next (src_node);
1340             }
1341             else
1342 #endif
1343                 for (i = 0; i < net_period_down; i++)
1344                     buf[i] = ((float) packet_bufX[i]) / 127.0;
1345         }
1346         else if (jack_port_is_midi (porttype))
1347         {
1348             // midi port, decode midi events
1349             // convert the data buffer to a standard format (uint32_t based)
1350             unsigned int buffer_size_uint32 = net_period_down / 2;
1351             uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;
1352             decode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
1353         }
1354         packet_bufX = (packet_bufX + net_period_down);
1355         node = jack_slist_next (node);
1356         chn++;
1357     }
1358 }
1359
1360 void
1361 render_jack_ports_to_payload_8bit (JSList *playback_ports, JSList *playback_srcs, jack_nframes_t nframes, void *packet_payload, jack_nframes_t net_period_up)
1362 {
1363     int chn = 0;
1364     JSList *node = playback_ports;
1365 #if HAVE_SAMPLERATE
1366     JSList *src_node = playback_srcs;
1367 #endif
1368
1369     int8_t *packet_bufX = (int8_t *)packet_payload;
1370
1371     while (node != NULL)
1372     {
1373 #if HAVE_SAMPLERATE
1374         SRC_DATA src;
1375 #endif
1376         int i;
1377         jack_port_t *port = (jack_port_t *) node->data;
1378
1379         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
1380         const char *porttype = jack_port_type (port);
1381
1382         if (jack_port_is_audio (porttype))
1383         {
1384 #if HAVE_SAMPLERATE
1385             // audio port, resample if necessary
1386             if (net_period_up != nframes)
1387             {
1388
1389                 SRC_STATE *src_state = src_node->data;
1390
1391                 float *floatbuf = alloca (sizeof (float) * net_period_up);
1392
1393                 src.data_in = buf;
1394                 src.input_frames = nframes;
1395
1396                 src.data_out = floatbuf;
1397                 src.output_frames = net_period_up;
1398
1399                 src.src_ratio = (float) net_period_up / (float) nframes;
1400                 src.end_of_input = 0;
1401
1402                 src_set_ratio (src_state, src.src_ratio);
1403                 src_process (src_state, &src);
1404
1405                 for (i = 0; i < net_period_up; i++)
1406                     packet_bufX[i] = floatbuf[i] * 127.0;
1407                 src_node = jack_slist_next (src_node);
1408             }
1409             else
1410 #endif
1411                 for (i = 0; i < net_period_up; i++)
1412                     packet_bufX[i] = buf[i] * 127.0;
1413         }
1414         else if (jack_port_is_midi (porttype))
1415         {
1416             // encode midi events from port to packet
1417             // convert the data buffer to a standard format (uint32_t based)
1418             unsigned int buffer_size_uint32 = net_period_up / 4;
1419             uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;
1420             encode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
1421         }
1422         packet_bufX = (packet_bufX + net_period_up);
1423         node = jack_slist_next (node);
1424         chn++;
1425     }
1426 }
1427
1428 #if HAVE_CELT
1429 // render functions for celt.
1430 void
1431 render_payload_to_jack_ports_celt (void *packet_payload, jack_nframes_t net_period_down, JSList *capture_ports, JSList *capture_srcs, jack_nframes_t nframes)
1432 {
1433     int chn = 0;
1434     JSList *node = capture_ports;
1435     JSList *src_node = capture_srcs;
1436
1437     unsigned char *packet_bufX = (unsigned char *)packet_payload;
1438
1439     while (node != NULL)
1440     {
1441         jack_port_t *port = (jack_port_t *) node->data;
1442         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
1443
1444         const char *porttype = jack_port_type (port);
1445
1446         if (jack_port_is_audio (porttype))
1447         {
1448             // audio port, decode celt data.
1449
1450             CELTDecoder *decoder = src_node->data;
1451             if( !packet_payload )
1452                 celt_decode_float( decoder, NULL, net_period_down, buf );
1453             else
1454                 celt_decode_float( decoder, packet_bufX, net_period_down, buf );
1455
1456             src_node = jack_slist_next (src_node);
1457         }
1458         else if (jack_port_is_midi (porttype))
1459         {
1460             // midi port, decode midi events
1461             // convert the data buffer to a standard format (uint32_t based)
1462             unsigned int buffer_size_uint32 = net_period_down / 2;
1463             uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;
1464             if( packet_payload )
1465                 decode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
1466         }
1467         packet_bufX = (packet_bufX + net_period_down);
1468         node = jack_slist_next (node);
1469         chn++;
1470     }
1471 }
1472
1473 void
1474 render_jack_ports_to_payload_celt (JSList *playback_ports, JSList *playback_srcs, jack_nframes_t nframes, void *packet_payload, jack_nframes_t net_period_up)
1475 {
1476     int chn = 0;
1477     JSList *node = playback_ports;
1478     JSList *src_node = playback_srcs;
1479
1480     unsigned char *packet_bufX = (unsigned char *)packet_payload;
1481
1482     while (node != NULL)
1483     {
1484         jack_port_t *port = (jack_port_t *) node->data;
1485         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
1486         const char *porttype = jack_port_type (port);
1487
1488         if (jack_port_is_audio (porttype))
1489         {
1490             // audio port, encode celt data.
1491
1492             int encoded_bytes;
1493             float *floatbuf = alloca (sizeof(float) * nframes );
1494             memcpy( floatbuf, buf, nframes*sizeof(float) );
1495             CELTEncoder *encoder = src_node->data;
1496             encoded_bytes = celt_encode_float( encoder, floatbuf, NULL, packet_bufX, net_period_up );
1497             if( encoded_bytes != net_period_up )
1498                 printf( "something in celt changed. netjack needs to be changed to handle this.\n" );
1499             src_node = jack_slist_next( src_node );
1500         }
1501         else if (jack_port_is_midi (porttype))
1502         {
1503             // encode midi events from port to packet
1504             // convert the data buffer to a standard format (uint32_t based)
1505             unsigned int buffer_size_uint32 = net_period_up / 2;
1506             uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;
1507             encode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
1508         }
1509         packet_bufX = (packet_bufX + net_period_up);
1510         node = jack_slist_next (node);
1511         chn++;
1512     }
1513 }
1514
1515 #endif
1516 /* Wrapper functions with bitdepth argument... */
1517 void
1518 render_payload_to_jack_ports (int bitdepth, void *packet_payload, jack_nframes_t net_period_down, JSList *capture_ports, JSList *capture_srcs, jack_nframes_t nframes, int dont_htonl_floats)
1519 {
1520     if (bitdepth == 8)
1521         render_payload_to_jack_ports_8bit (packet_payload, net_period_down, capture_ports, capture_srcs, nframes);
1522     else if (bitdepth == 16)
1523         render_payload_to_jack_ports_16bit (packet_payload, net_period_down, capture_ports, capture_srcs, nframes);
1524 #if HAVE_CELT
1525     else if (bitdepth == CELT_MODE)
1526         render_payload_to_jack_ports_celt (packet_payload, net_period_down, capture_ports, capture_srcs, nframes);
1527 #endif
1528     else
1529         render_payload_to_jack_ports_float (packet_payload, net_period_down, capture_ports, capture_srcs, nframes, dont_htonl_floats);
1530 }
1531
1532 void
1533 render_jack_ports_to_payload (int bitdepth, JSList *playback_ports, JSList *playback_srcs, jack_nframes_t nframes, void *packet_payload, jack_nframes_t net_period_up, int dont_htonl_floats)
1534 {
1535     if (bitdepth == 8)
1536         render_jack_ports_to_payload_8bit (playback_ports, playback_srcs, nframes, packet_payload, net_period_up);
1537     else if (bitdepth == 16)
1538         render_jack_ports_to_payload_16bit (playback_ports, playback_srcs, nframes, packet_payload, net_period_up);
1539 #if HAVE_CELT
1540     else if (bitdepth == CELT_MODE)
1541         render_jack_ports_to_payload_celt (playback_ports, playback_srcs, nframes, packet_payload, net_period_up);
1542 #endif
1543     else
1544         render_jack_ports_to_payload_float (playback_ports, playback_srcs, nframes, packet_payload, net_period_up, dont_htonl_floats);
1545 }