drivers/netjack/netjack_packet_noReOrder.c

   1
   2 /*
   3  * NetJack - Packet Handling functions
   4  *
   5  * used by the driver and the jacknet_client
   6  *
   7  * Copyright (C) 2006 Torben Hohn <torbenh@gmx.de>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  * $Id: net_driver.c,v 1.16 2006/03/20 19:41:37 torbenh Exp $
  24  *
  25  */
  26
  27
  28 #include <math.h>
  29 #include <stdio.h>
  30 #include <memory.h>
  31 #include <unistd.h>
  32 #include <stdlib.h>
  33 #include <errno.h>
  34 #include <stdarg.h>
  35
  36 #include <jack/types.h>
  37 #include <jack/engine.h>
  38
  39 #include <sys/types.h>
  40 #include <sys/socket.h>
  41 #include <netinet/in.h>
  42
  43 #include <samplerate.h>
  44
  45 #include "net_driver.h"
  46 #include "netjack_packet.h"
  47
  48 int fraggo = 0;
  49
  50 void
  51 packet_header_hton(jacknet_packet_header *pkthdr)
  52 {
  53     pkthdr->channels = htonl(pkthdr->channels);
  54     pkthdr->period_size = htonl(pkthdr->period_size);
  55     pkthdr->sample_rate = htonl(pkthdr->sample_rate);
  56     pkthdr->sync_state = htonl(pkthdr->sync_state);
  57     pkthdr->transport_frame = htonl(pkthdr->transport_frame);
  58     pkthdr->transport_state = htonl(pkthdr->transport_state);
  59     pkthdr->framecnt = htonl(pkthdr->framecnt);
  60     pkthdr->latency = htonl(pkthdr->latency);
  61     pkthdr->reply_port = htonl(pkthdr->reply_port);
  62     pkthdr->mtu = htonl(pkthdr->mtu);
  63     pkthdr->fragment_nr = htonl(pkthdr->fragment_nr);
  64 }
  65
  66 void
  67 packet_header_ntoh(jacknet_packet_header *pkthdr)
  68 {
  69     pkthdr->channels = ntohl(pkthdr->channels);
  70     pkthdr->period_size = ntohl(pkthdr->period_size);
  71     pkthdr->sample_rate = ntohl(pkthdr->sample_rate);
  72     pkthdr->sync_state = ntohl(pkthdr->sync_state);
  73     pkthdr->transport_frame = ntohl(pkthdr->transport_frame);
  74     pkthdr->transport_state = ntohl(pkthdr->transport_state);
  75     pkthdr->framecnt = ntohl(pkthdr->framecnt);
  76     pkthdr->latency = ntohl(pkthdr->latency);
  77     pkthdr->reply_port = ntohl(pkthdr->reply_port);
  78     pkthdr->mtu = ntohl(pkthdr->mtu);
  79     pkthdr->fragment_nr = ntohl(pkthdr->fragment_nr);
  80 }
  81
  82 int get_sample_size(int bitdepth)
  83 {
  84     if (bitdepth == 8)
  85         return sizeof(int8_t);
  86     if (bitdepth == 16)
  87         return sizeof(int16_t);
  88
  89     return sizeof(int32_t);
  90 }
  91
  92
  93 // fragmented packet IO
  94
  95 int netjack_recvfrom(int sockfd, char *packet_buf, int pkt_size, int flags, struct sockaddr *addr, socklen_t *addr_size, int mtu)
  96 {
  97     char *rx_packet;
  98     char *dataX;
  99
 100     int fragment_payload_size;
 101
 102     // Copy the packet header to the tx pack first.
 103     //memcpy(tx_packet, packet_buf, sizeof(jacknet_packet_header));
 104
 105     jacknet_packet_header *pkthdr;
 106
 107     // Now loop and send all
 108     char *packet_bufX;
 109
 110     // wait for fragment_nr == 0
 111     int rcv_len;
 112
 113     rx_packet = alloca(mtu);
 114     dataX = rx_packet + sizeof(jacknet_packet_header);
 115
 116     fragment_payload_size = mtu - sizeof(jacknet_packet_header);
 117
 118     // Copy the packet header to the tx pack first.
 119     //memcpy(tx_packet, packet_buf, sizeof(jacknet_packet_header));
 120
 121     pkthdr = (jacknet_packet_header *)rx_packet;
 122
 123     // Now loop and send all
 124     packet_bufX = packet_buf + sizeof(jacknet_packet_header);
 125
 126
 127     if (pkt_size <= mtu)
 128     {
 129         return recvfrom(sockfd, packet_buf, pkt_size, flags, addr, addr_size);
 130     } else
 131     {
 132 rx_again:
 133         rcv_len = recvfrom(sockfd, rx_packet, mtu, 0, addr, addr_size);
 134         if (rcv_len < 0)
 135             return rcv_len;
 136
 137         if (rcv_len >= sizeof(jacknet_packet_header)) {
 138             //printf("got fragmentooooo_nr = %d recv_len = %d\n",  ntohl(pkthdr->fragment_nr), rcv_len);
 139             if ((ntohl(pkthdr->fragment_nr)) != 0)
 140                 goto rx_again;
 141         } else {
 142             goto rx_again;
 143         }
 144         //goto rx_again;
 145
 146         //printf("ok... lets go...\n");
 147         // ok... we have read a fragement 0;
 148         // copy the packet header...
 149         memcpy(packet_buf, rx_packet, sizeof(jacknet_packet_header));
 150
 151         int fragment_count = 0;
 152
 153         while (packet_bufX <= (packet_buf + pkt_size - fragment_payload_size)) {
 154
 155             //printf("enter loop: fragment_count = %d, pkthdr->fragment_nr = %d\n", fragment_count, pkthdr->fragment_nr);
 156             // check fragment number.
 157             if ((ntohl(pkthdr->fragment_nr)) != fragment_count) {
 158                 printf("got unexpected fragment %d (expected %d)\n", ntohl(pkthdr->fragment_nr), fragment_count);
 159                 return sizeof(jacknet_packet_header) + (fragment_count) * fragment_payload_size;
 160             } else
 161                 //printf("expected fragment %d\n", fragment_count);
 162
 163                 // copy the payload into the packet buffer...
 164                 memcpy(packet_bufX, dataX, fragment_payload_size);
 165
 166             rcv_len = recvfrom(sockfd, rx_packet, mtu, 0, addr, addr_size);
 167             //printf("got fragmen_nr = %d rcv_len = %d\n",  ntohl(pkthdr->fragment_nr), rcv_len);
 168             //printf("got fragmen_nr = %d\n",  ntohl(pkthdr->fragment_nr));
 169             if (rcv_len < 0)
 170                 return -1;
 171
 172             packet_bufX += fragment_payload_size;
 173             fragment_count++;
 174         }
 175
 176         //printf("at the end rcv_len = %d\n ", rcv_len);
 177         int last_payload_size = packet_bufX - packet_buf - pkt_size;
 178         memcpy(packet_bufX, dataX, rcv_len - sizeof(jacknet_packet_header));
 179     }
 180     return pkt_size;
 181 }
 182
 183 int netjack_recv(int sockfd, char *packet_buf, int pkt_size, int flags, int mtu)
 184 {
 185     if (pkt_size <= mtu) {
 186         return recv(sockfd, packet_buf, pkt_size, flags);
 187     } else {
 188         char *rx_packet = alloca(mtu);
 189         char *dataX = rx_packet + sizeof(jacknet_packet_header);
 190
 191         int fragment_payload_size = mtu - sizeof(jacknet_packet_header);
 192         jacknet_packet_header *pkthdr = (jacknet_packet_header *)rx_packet;
 193
 194         // Now loop and send all
 195         char *packet_bufX = packet_buf + sizeof(jacknet_packet_header);
 196
 197         // wait for fragment_nr == 0
 198         int rcv_len;
 199 rx_again:
 200         rcv_len = recv(sockfd, rx_packet, mtu, flags);
 201         if (rcv_len < 0)
 202             return rcv_len;
 203
 204         if (rcv_len >= sizeof(jacknet_packet_header)) {
 205             //printf("got fragmentooo_nr = %d\n",  ntohl(pkthdr->fragment_nr));
 206             if (ntohl(pkthdr->fragment_nr) != 0)
 207                 goto rx_again;
 208         } else {
 209             goto rx_again;
 210         }
 211
 212         //printf("ok we got a fragment 0\n");
 213         // ok... we have read a fragement 0;
 214         // copy the packet header...
 215         memcpy(packet_buf, rx_packet, sizeof(jacknet_packet_header));
 216
 217         int fragment_count = 0;
 218
 219         while (packet_bufX <= (packet_buf + pkt_size - fragment_payload_size)) {
 220
 221             // check fragment number.
 222             if (ntohl(pkthdr->fragment_nr) != fragment_count) {
 223                 printf("got unexpected fragment %d (expected %d)\n", ntohl(pkthdr->fragment_nr), fragment_count);
 224                 return sizeof(jacknet_packet_header) + (fragment_count - 1) * fragment_payload_size;
 225             }
 226
 227             // copy the payload into the packet buffer...
 228             memcpy(packet_bufX, dataX, fragment_payload_size);
 229
 230             rcv_len = recv(sockfd, rx_packet, mtu, flags);
 231             //printf("got fragmen_nr = %d rcv_len = %d\n",  ntohl(pkthdr->fragment_nr), rcv_len);
 232             if (rcv_len < 0)
 233                 return -1;
 234
 235             packet_bufX += fragment_payload_size;
 236             fragment_count++;
 237         }
 238
 239         //int last_payload_size = packet_bufX - packet_buf - pkt_size;
 240         //memcpy(packet_bufX, dataX, rcv_len - sizeof(jacknet_packet_header));
 241     }
 242     return pkt_size;
 243 }
 244
 245 void netjack_sendto(int sockfd, char *packet_buf, int pkt_size, int flags, struct sockaddr *addr, int addr_size, int mtu)
 246 {
 247     int frag_cnt = 0;
 248     char *tx_packet, *dataX;
 249     jacknet_packet_header *pkthdr;
 250
 251     tx_packet = alloca(mtu + 10);
 252     dataX = tx_packet + sizeof(jacknet_packet_header);
 253     pkthdr = (jacknet_packet_header *)tx_packet;
 254
 255     int fragment_payload_size = mtu - sizeof(jacknet_packet_header);
 256
 257     if (pkt_size <= mtu) {
 258         sendto(sockfd, packet_buf, pkt_size, flags, addr, addr_size);
 259     } else {
 260
 261         // Copy the packet header to the tx pack first.
 262         memcpy(tx_packet, packet_buf, sizeof(jacknet_packet_header));
 263
 264         // Now loop and send all
 265         char *packet_bufX = packet_buf + sizeof(jacknet_packet_header);
 266
 267
 268         while (packet_bufX < (packet_buf + pkt_size - fragment_payload_size)) {
 269             pkthdr->fragment_nr = htonl(frag_cnt++);
 270             memcpy(dataX, packet_bufX, fragment_payload_size);
 271
 272             int err = sendto(sockfd, tx_packet, mtu, flags, addr, addr_size);
 273
 274             packet_bufX += fragment_payload_size;
 275         }
 276
 277         int last_payload_size = packet_buf + pkt_size - packet_bufX;
 278         memcpy(dataX, packet_bufX, last_payload_size);
 279         pkthdr->fragment_nr = htonl(frag_cnt);
 280         //printf("last fragment_count = %d, payload_size = %d\n", fragment_count, last_payload_size);
 281
 282         // sendto(last_pack_size);
 283         sendto(sockfd, tx_packet, last_payload_size + sizeof(jacknet_packet_header), flags, addr, addr_size);
 284     }
 285 }
 286
 287 // render functions for float
 288 void 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)
 289 {
 290     channel_t chn = 0;
 291     JSList *node = capture_ports;
 292     JSList *src_node = capture_srcs;
 293
 294     uint32_t *packet_bufX = (uint32_t *)packet_payload;
 295
 296     while (node != NULL) {
 297         int i;
 298         int_float_t val;
 299         SRC_DATA src;
 300
 301         jack_port_t *port = (jack_port_t *) node->data;
 302         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
 303
 304         if (net_period_down != nframes) {
 305             SRC_STATE *src_state = src_node->data;
 306             for (i = 0; i < net_period_down; i++) {
 307                 packet_bufX[i] = ntohl(packet_bufX[i]);
 308             }
 309
 310             src.data_in = (float *)packet_bufX;
 311             src.input_frames = net_period_down;
 312
 313             src.data_out = buf;
 314             src.output_frames = nframes;
 315
 316             src.src_ratio = (float) nframes / (float) net_period_down;
 317             src.end_of_input = 0;
 318
 319             src_set_ratio(src_state, src.src_ratio);
 320             src_process(src_state, &src);
 321             src_node = jack_slist_next (src_node);
 322         } else {
 323             for (i = 0; i < net_period_down; i++) {
 324                 val.i = packet_bufX[i];
 325                 val.i = ntohl(val.i);
 326                 buf[i] = val.f;
 327             }
 328         }
 329
 330         packet_bufX = (packet_bufX + net_period_down);
 331         node = jack_slist_next (node);
 332         chn++;
 333     }
 334 }
 335
 336 void 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)
 337 {
 338     channel_t chn = 0;
 339     JSList *node = playback_ports;
 340     JSList *src_node = playback_srcs;
 341
 342     uint32_t *packet_bufX = (uint32_t *)packet_payload;
 343
 344     while (node != NULL) {
 345         SRC_DATA src;
 346         int i;
 347         int_float_t val;
 348         jack_port_t *port = (jack_port_t *) node->data;
 349         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
 350
 351         if (net_period_up != nframes) {
 352             SRC_STATE *src_state = src_node->data;
 353             src.data_in = buf;
 354             src.input_frames = nframes;
 355
 356             src.data_out = (float *) packet_bufX;
 357             src.output_frames = net_period_up;
 358
 359             src.src_ratio = (float) net_period_up / (float) nframes;
 360             src.end_of_input = 0;
 361
 362             src_set_ratio(src_state, src.src_ratio);
 363             src_process(src_state, &src);
 364
 365             for (i = 0; i < net_period_up; i++) {
 366                 packet_bufX[i] = htonl(packet_bufX[i]);
 367             }
 368             src_node = jack_slist_next (src_node);
 369         } else {
 370             for (i = 0; i < net_period_up; i++) {
 371                 val.f = buf[i];
 372                 val.i = htonl(val.i);
 373                 packet_bufX[i] = val.i;
 374             }
 375         }
 376
 377         packet_bufX = (packet_bufX + net_period_up);
 378         node = jack_slist_next (node);
 379         chn++;
 380     }
 381 }
 382
 383 // render functions for 16bit
 384 void 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)
 385 {
 386     channel_t chn = 0;
 387     JSList *node = capture_ports;
 388     JSList *src_node = capture_srcs;
 389
 390     uint16_t *packet_bufX = (uint16_t *)packet_payload;
 391
 392     while (node != NULL) {
 393         int i;
 394         //uint32_t val;
 395         SRC_DATA src;
 396
 397         jack_port_t *port = (jack_port_t *) node->data;
 398         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
 399
 400         float *floatbuf = alloca(sizeof(float) * net_period_down);
 401
 402         if (net_period_down != nframes) {
 403             SRC_STATE *src_state = src_node->data;
 404             for (i = 0; i < net_period_down; i++) {
 405                 floatbuf[i] = ((float) ntohs(packet_bufX[i])) / 32767.0 - 1.0;
 406             }
 407
 408             src.data_in = floatbuf;
 409             src.input_frames = net_period_down;
 410
 411             src.data_out = buf;
 412             src.output_frames = nframes;
 413
 414             src.src_ratio = (float) nframes / (float) net_period_down;
 415             src.end_of_input = 0;
 416
 417             src_set_ratio(src_state, src.src_ratio);
 418             src_process(src_state, &src);
 419             src_node = jack_slist_next (src_node);
 420         } else {
 421             for (i = 0; i < net_period_down; i++) {
 422                 buf[i] = ((float) ntohs(packet_bufX[i])) / 32768.0 - 1.0;
 423             }
 424         }
 425
 426         packet_bufX = (packet_bufX + net_period_down);
 427         node = jack_slist_next (node);
 428         chn++;
 429     }
 430 }
 431
 432 void 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)
 433 {
 434     channel_t chn = 0;
 435     JSList *node = playback_ports;
 436     JSList *src_node = playback_srcs;
 437
 438     uint16_t *packet_bufX = (uint16_t *)packet_payload;
 439
 440     while (node != NULL) {
 441         SRC_DATA src;
 442         int i;
 443         jack_port_t *port = (jack_port_t *) node->data;
 444         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
 445
 446         if (net_period_up != nframes) {
 447             SRC_STATE *src_state = src_node->data;
 448
 449             float *floatbuf = alloca(sizeof(float) * net_period_up);
 450
 451             src.data_in = buf;
 452             src.input_frames = nframes;
 453
 454             src.data_out = floatbuf;
 455             src.output_frames = net_period_up;
 456
 457             src.src_ratio = (float) net_period_up / (float) nframes;
 458             src.end_of_input = 0;
 459
 460             src_set_ratio(src_state, src.src_ratio);
 461             src_process(src_state, &src);
 462
 463             for (i = 0; i < net_period_up; i++) {
 464                 packet_bufX[i] = htons((floatbuf[i] + 1.0) * 32767.0);
 465             }
 466             src_node = jack_slist_next (src_node);
 467         } else {
 468             for (i = 0; i < net_period_up; i++) {
 469                 packet_bufX[i] = htons((buf[i] + 1.0) * 32767.0);
 470             }
 471         }
 472
 473         packet_bufX = (packet_bufX + net_period_up);
 474         node = jack_slist_next (node);
 475         chn++;
 476     }
 477 }
 478
 479 // render functions for 8bit
 480
 481 void 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)
 482 {
 483     channel_t chn = 0;
 484     JSList *node = capture_ports;
 485     JSList *src_node = capture_srcs;
 486
 487     int8_t *packet_bufX = (int8_t *)packet_payload;
 488
 489     while (node != NULL) {
 490         int i;
 491         //uint32_t val;
 492         SRC_DATA src;
 493
 494         jack_port_t *port = (jack_port_t *) node->data;
 495         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
 496
 497         float *floatbuf = alloca(sizeof(float) * net_period_down);
 498
 499         if (net_period_down != nframes) {
 500             SRC_STATE *src_state = src_node->data;
 501             for (i = 0; i < net_period_down; i++) {
 502                 floatbuf[i] = ((float) packet_bufX[i]) / 127.0;
 503             }
 504
 505             src.data_in = floatbuf;
 506             src.input_frames = net_period_down;
 507
 508             src.data_out = buf;
 509             src.output_frames = nframes;
 510
 511             src.src_ratio = (float) nframes / (float) net_period_down;
 512             src.end_of_input = 0;
 513
 514             src_set_ratio(src_state, src.src_ratio);
 515             src_process(src_state, &src);
 516             src_node = jack_slist_next (src_node);
 517         } else {
 518             for (i = 0; i < net_period_down; i++) {
 519                 buf[i] = ((float) packet_bufX[i]) / 127.0;
 520             }
 521         }
 522
 523         packet_bufX = (packet_bufX + net_period_down);
 524         node = jack_slist_next (node);
 525         chn++;
 526     }
 527 }
 528
 529 void 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)
 530 {
 531     channel_t chn = 0;
 532     JSList *node = playback_ports;
 533     JSList *src_node = playback_srcs;
 534
 535     int8_t *packet_bufX = (int8_t *)packet_payload;
 536
 537     while (node != NULL) {
 538         SRC_DATA src;
 539         int i;
 540         jack_port_t *port = (jack_port_t *) node->data;
 541         jack_default_audio_sample_t* buf = jack_port_get_buffer (port, nframes);
 542
 543         if (net_period_up != nframes) {
 544             SRC_STATE *src_state = src_node->data;
 545
 546             float *floatbuf = alloca(sizeof(float) * net_period_up);
 547
 548             src.data_in = buf;
 549             src.input_frames = nframes;
 550
 551             src.data_out = floatbuf;
 552             src.output_frames = net_period_up;
 553
 554             src.src_ratio = (float) net_period_up / (float) nframes;
 555             src.end_of_input = 0;
 556
 557             src_set_ratio(src_state, src.src_ratio);
 558             src_process(src_state, &src);
 559
 560             for (i = 0; i < net_period_up; i++) {
 561                 packet_bufX[i] = floatbuf[i] * 127.0;
 562             }
 563             src_node = jack_slist_next (src_node);
 564         } else {
 565             for (i = 0; i < net_period_up; i++) {
 566                 packet_bufX[i] = buf[i] * 127.0;
 567             }
 568         }
 569
 570         packet_bufX = (packet_bufX + net_period_up);
 571         node = jack_slist_next (node);
 572         chn++;
 573     }
 574 }
 575
 576 // wrapper functions with bitdepth argument...
 577 void 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)
 578 {
 579     if (bitdepth == 8)
 580         render_payload_to_jack_ports_8bit(packet_payload, net_period_down, capture_ports, capture_srcs, nframes);
 581     else if (bitdepth == 16)
 582         render_payload_to_jack_ports_16bit(packet_payload, net_period_down, capture_ports, capture_srcs, nframes);
 583     else
 584         render_payload_to_jack_ports_float(packet_payload, net_period_down, capture_ports, capture_srcs, nframes);
 585 }
 586
 587 void 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)
 588 {
 589     if (bitdepth == 8)
 590         render_jack_ports_to_payload_8bit(playback_ports, playback_srcs, nframes, packet_payload, net_period_up);
 591     else if (bitdepth == 16)
 592         render_jack_ports_to_payload_16bit(playback_ports, playback_srcs, nframes, packet_payload, net_period_up);
 593     else
 594         render_jack_ports_to_payload_float(playback_ports, playback_srcs, nframes, packet_payload, net_period_up);
 595 }