jackaudio
/
jack1
mirror of https://github.com/jackaudio/jack1
1
0
Fork 0
Code Releases 19 Activity
jack1 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1123 Commits
4 Branches
6.5MB
Tree: 4655fc1972
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4655fc1972'
${ noResults }
jack1/drivers/netjack/net_driver.c

657 lines
20KB
Raw Blame History 

  1. /* -*- mode: c; c-file-style: "linux"; -*- */

  2. /*

  3. NetJack Driver

  4. 

  5. Copyright (C) 2008 Pieter Palmers <pieterpalmers@users.sourceforge.net>

  6. Copyright (C) 2006 Torben Hohn <torbenh@gmx.de>

  7. Copyright (C) 2003 Robert Ham <rah@bash.sh>

  8. Copyright (C) 2001 Paul Davis

  9. 

  10. This program is free software; you can redistribute it and/or modify

  11. it under the terms of the GNU General Public License as published by

  12. the Free Software Foundation; either version 2 of the License, or

  13. (at your option) any later version.

  14. 

  15. This program is distributed in the hope that it will be useful,

  16. but WITHOUT ANY WARRANTY; without even the implied warranty of

  17. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  18. GNU General Public License for more details.

  19. 

  20. You should have received a copy of the GNU General Public License

  21. along with this program; if not, write to the Free Software

  22. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  23. 

  24. $Id: net_driver.c,v 1.17 2006/04/16 20:16:10 torbenh Exp $

  25. */

  26. 

  27. #include <math.h>

  28. #include <stdio.h>

  29. #include <memory.h>

  30. #include <unistd.h>

  31. #include <stdlib.h>

  32. #include <errno.h>

  33. #include <stdarg.h>

  34. #include <sys/mman.h>

  35. 

  36. #include <jack/types.h>

  37. #include <jack/engine.h>

  38. #include <sysdeps/time.h>

  39. 

  40. #include <sys/types.h>

  41. 

  42. #include "config.h"

  43. 

  44. 

  45. #include "netjack.h"

  46. #include "netjack_packet.h"

  47. #include "net_driver.h"

  48. 

  49. #undef DEBUG_WAKEUP

  50. 

  51. 

  52. #define MIN(x,y) ((x)<(y) ? (x) : (y))

  53. 

  54. static jack_transport_state_t last_transport_state;

  55. static int sync_state = TRUE;

  56. 

  57. static jack_nframes_t

  58. net_driver_wait (net_driver_t *driver, int extra_fd, int *status, float *delayed_usecs)

  59. {

  60.     netjack_driver_state_t *netj = &( driver->netj );

  61. 

  62.     netjack_wait( netj );

  63.     

  64.     driver->last_wait_ust = jack_get_microseconds ();

  65.     driver->engine->transport_cycle_start (driver->engine, driver->last_wait_ust);

  66. 

  67.     /* this driver doesn't work so well if we report a delay */

  68.     /* XXX: this might not be the case anymore */

  69.     /*      the delayed _usecs is a resync or something. */

  70.     *delayed_usecs = 0;		/* lie about it */

  71.     *status = 0;

  72.     return netj->period_size;

  73. }

  74. 

  75. static int

  76. net_driver_run_cycle (net_driver_t *driver)

  77. {

  78.     jack_engine_t *engine = driver->engine;

  79.     //netjack_driver_state_t *netj = &(driver->netj);

  80.     int wait_status = -1;

  81.     float delayed_usecs;

  82. 

  83.     jack_nframes_t nframes = net_driver_wait (driver, -1, &wait_status,

  84.                              &delayed_usecs);

  85. 

  86.     // XXX: xrun code removed.

  87.     //      especially with celt there are no real xruns anymore.

  88.     //      things are different on the net.

  89. 

  90.     if (wait_status == 0)

  91.         return engine->run_cycle (engine, nframes, delayed_usecs);

  92. 

  93.     if (wait_status < 0)

  94.         return -1;

  95.     else

  96.         return 0;

  97. }

  98. 

  99. static int

  100. net_driver_null_cycle (net_driver_t* driver, jack_nframes_t nframes)

  101. {

  102.     // TODO: talk to paul about this.

  103.     //       do i wait here ?

  104.     //       just sending out a packet marked with junk ?

  105. 

  106.     netjack_driver_state_t *netj = &(driver->netj);

  107.     int sync_state = (driver->engine->control->sync_remain <= 1);

  108.     netjack_send_silence( netj, sync_state );

  109. 

  110.     return 0;

  111. }

  112. 

  113. static int

  114. net_driver_bufsize (net_driver_t* driver, jack_nframes_t nframes)

  115. {

  116.     netjack_driver_state_t *netj = &(driver->netj);

  117.     if (nframes != netj->period_size)

  118.         return EINVAL;

  119. 

  120.     return 0;

  121. }

  122. 

  123. static int

  124. net_driver_read (net_driver_t* driver, jack_nframes_t nframes)

  125. {

  126.     netjack_driver_state_t *netj = &(driver->netj);

  127. 

  128.     jack_position_t local_trans_pos;

  129.     jack_transport_state_t local_trans_state;

  130. 

  131.     unsigned int *packet_buf, *packet_bufX;

  132. 

  133.     if( ! netj->packet_data_valid ) {

  134. 	render_payload_to_jack_ports (netj->bitdepth, NULL, netj->net_period_down, netj->capture_ports, netj->capture_srcs, nframes, netj->dont_htonl_floats );

  135. 	return 0;

  136.     }

  137.     packet_buf = netj->rx_buf;

  138. 

  139.     jacknet_packet_header *pkthdr = (jacknet_packet_header *)packet_buf;

  140. 

  141.     packet_bufX = packet_buf + sizeof(jacknet_packet_header) / sizeof(jack_default_audio_sample_t);

  142. 

  143.     netj->reply_port = pkthdr->reply_port;

  144.     netj->latency = pkthdr->latency;

  145. 

  146.     // Special handling for latency=0

  147.     if( netj->latency == 0 )

  148. 	netj->resync_threshold = 0;

  149.     else

  150. 	netj->resync_threshold = MIN( 15, pkthdr->latency-1 );

  151. 

  152.     // check whether, we should handle the transport sync stuff, or leave trnasports untouched.

  153.     if (netj->handle_transport_sync) {

  154. 	int compensated_tranport_pos = (pkthdr->transport_frame + (pkthdr->latency * nframes) + netj->codec_latency);

  155. 

  156.         // read local transport info....

  157.         local_trans_state = jack_transport_query(netj->client, &local_trans_pos);

  158. 

  159.         // Now check if we have to start or stop local transport to sync to remote...

  160.         switch (pkthdr->transport_state) {

  161.             case JackTransportStarting:

  162.                 // the master transport is starting... so we set our reply to the sync_callback;

  163.                 if (local_trans_state == JackTransportStopped) {

  164.                     jack_transport_start(netj->client);

  165.                     last_transport_state = JackTransportStopped;

  166.                     sync_state = FALSE;

  167.                     jack_info("locally stopped... starting...");

  168.                 }

  169. 

  170.                 if (local_trans_pos.frame != compensated_tranport_pos)

  171. 		{

  172.                     jack_transport_locate(netj->client, compensated_tranport_pos);

  173.                     last_transport_state = JackTransportRolling;

  174.                     sync_state = FALSE;

  175.                     jack_info("starting locate to %d", compensated_tranport_pos );

  176.                 }

  177.                 break;

  178.             case JackTransportStopped:

  179.                 sync_state = TRUE;

  180.                 if (local_trans_pos.frame != (pkthdr->transport_frame)) {

  181.                     jack_transport_locate(netj->client, (pkthdr->transport_frame));

  182.                     jack_info("transport is stopped locate to %d", pkthdr->transport_frame);

  183.                 }

  184.                 if (local_trans_state != JackTransportStopped)

  185.                     jack_transport_stop(netj->client);

  186.                 break;

  187.             case JackTransportRolling:

  188.                 sync_state = TRUE;

  189. //		    		if(local_trans_pos.frame != (pkthdr->transport_frame + (pkthdr->latency) * nframes)) {

  190. //				    jack_transport_locate(netj->client, (pkthdr->transport_frame + (pkthdr->latency + 2) * nframes));

  191. //				    jack_info("running locate to %d", pkthdr->transport_frame + (pkthdr->latency)*nframes);

  192. //		    		}

  193.                 if (local_trans_state != JackTransportRolling)

  194.                     jack_transport_start (netj->client);

  195.                 break;

  196. 

  197.             case JackTransportLooping:

  198.                 break;

  199.         }

  200.     }

  201. 

  202.     render_payload_to_jack_ports (netj->bitdepth, packet_bufX, netj->net_period_down, netj->capture_ports, netj->capture_srcs, nframes, netj->dont_htonl_floats );

  203. 

  204.     return 0;

  205. }

  206. 

  207. static int

  208. net_driver_write (net_driver_t* driver, jack_nframes_t nframes)

  209. {

  210.     netjack_driver_state_t *netj = &(driver->netj);

  211. 

  212.     int sync_state = (driver->engine->control->sync_remain <= 1);;

  213. 

  214.     uint32_t *packet_buf, *packet_bufX;

  215. 

  216.     int packet_size = get_sample_size(netj->bitdepth) * netj->playback_channels * netj->net_period_up + sizeof(jacknet_packet_header);

  217.     jacknet_packet_header *pkthdr; 

  218. 

  219.     packet_buf = alloca(packet_size);

  220.     pkthdr = (jacknet_packet_header *)packet_buf;

  221. 

  222.     if( netj->running_free ) {

  223. 	return 0;

  224.     }

  225. 

  226.     // offset packet_bufX by the packetheader.

  227.     packet_bufX = packet_buf + sizeof(jacknet_packet_header) / sizeof(jack_default_audio_sample_t);

  228. 

  229.     pkthdr->sync_state = sync_state;

  230.     pkthdr->latency = netj->time_to_deadline;

  231.     //printf( "time to deadline = %d  goodness=%d\n", (int)netj->time_to_deadline, netj->deadline_goodness );

  232.     pkthdr->framecnt = netj->expected_framecnt;

  233. 

  234. 

  235.     render_jack_ports_to_payload(netj->bitdepth, netj->playback_ports, netj->playback_srcs, nframes, packet_bufX, netj->net_period_up, netj->dont_htonl_floats );

  236. 

  237.     packet_header_hton(pkthdr);

  238.     if (netj->srcaddress_valid)

  239.     {

  240. 	int r;

  241. 

  242. #ifndef MSG_CONFIRM

  243. 	static const int flag = 0;

  244. #else

  245. 	static const int flag = MSG_CONFIRM;

  246. #endif

  247. 

  248.         if (netj->reply_port)

  249.             netj->syncsource_address.sin_port = htons(netj->reply_port);

  250. 

  251. 	for( r=0; r<netj->redundancy; r++ )

  252. 	    netjack_sendto(netj->outsockfd, (char *)packet_buf, packet_size,

  253. 			   flag, (struct sockaddr*)&(netj->syncsource_address), sizeof(struct sockaddr_in), netj->mtu);

  254.     }

  255. 

  256.     return 0;

  257. }

  258. 

  259. 

  260. static int

  261. net_driver_attach (net_driver_t *driver)

  262. {

  263.     netjack_driver_state_t *netj = &( driver->netj );

  264.     driver->engine->set_buffer_size (driver->engine, netj->period_size);

  265.     driver->engine->set_sample_rate (driver->engine, netj->sample_rate);

  266. 

  267.     netjack_attach( netj );

  268.     return 0;

  269. }

  270. 

  271. static int

  272. net_driver_detach (net_driver_t *driver)

  273. {

  274.     netjack_driver_state_t *netj = &( driver->netj );

  275. 

  276.     if (driver->engine == 0)

  277.         return 0;

  278. 

  279.     netjack_detach( netj );

  280.     return 0;

  281. }

  282. 

  283. static void

  284. net_driver_delete (net_driver_t *driver)

  285. {

  286.     jack_driver_nt_finish ((jack_driver_nt_t *) driver);

  287.     free (driver);

  288. }

  289. 

  290. static jack_driver_t *

  291. net_driver_new (jack_client_t * client,

  292.                 char *name,

  293.                 unsigned int capture_ports,

  294.                 unsigned int playback_ports,

  295.                 unsigned int capture_ports_midi,

  296.                 unsigned int playback_ports_midi,

  297.                 jack_nframes_t sample_rate,

  298.                 jack_nframes_t period_size,

  299.                 unsigned int listen_port,

  300.                 unsigned int transport_sync,

  301.                 unsigned int resample_factor,

  302.                 unsigned int resample_factor_up,

  303.                 unsigned int bitdepth,

  304. 		unsigned int use_autoconfig,

  305. 		unsigned int latency,

  306. 		unsigned int redundancy,

  307. 		int dont_htonl_floats,

  308. 		int always_deadline)

  309. {

  310.     net_driver_t * driver;

  311. 

  312.     jack_info ("creating net driver ... %s|%" PRIu32 "|%" PRIu32

  313.             "|%u|%u|%u|transport_sync:%u", name, sample_rate, period_size, listen_port,

  314.             capture_ports, playback_ports, transport_sync);

  315. 

  316.     driver = (net_driver_t *) calloc (1, sizeof (net_driver_t));

  317. 

  318.     jack_driver_nt_init ((jack_driver_nt_t *) driver);

  319. 

  320.     driver->write         = (JackDriverWriteFunction)      net_driver_write;

  321.     driver->read          = (JackDriverReadFunction)       net_driver_read;

  322.     driver->null_cycle    = (JackDriverNullCycleFunction)  net_driver_null_cycle;

  323.     driver->nt_attach     = (JackDriverNTAttachFunction)   net_driver_attach;

  324.     driver->nt_detach     = (JackDriverNTDetachFunction)   net_driver_detach;

  325.     driver->nt_bufsize    = (JackDriverNTBufSizeFunction)  net_driver_bufsize;

  326.     driver->nt_run_cycle  = (JackDriverNTRunCycleFunction) net_driver_run_cycle;

  327. 

  328.     driver->last_wait_ust = 0;

  329.     driver->engine = NULL;

  330. 

  331.     netjack_driver_state_t *netj = &(driver->netj);

  332. 

  333.     netjack_init ( netj,

  334. 		client,

  335.                 name,

  336.                 capture_ports,

  337.                 playback_ports,

  338.                 capture_ports_midi,

  339.                 playback_ports_midi,

  340.                 sample_rate,

  341.                 period_size,

  342.                 listen_port,

  343.                 transport_sync,

  344.                 resample_factor,

  345.                 resample_factor_up,

  346.                 bitdepth,

  347. 		use_autoconfig,

  348. 		latency,

  349. 		redundancy,

  350. 		dont_htonl_floats,

  351. 	        always_deadline	);

  352. 

  353.     netjack_startup( netj );

  354. 

  355.     jack_info ("netjack: period   : up: %d / dn: %d", netj->net_period_up, netj->net_period_down);

  356.     jack_info ("netjack: framerate: %d", netj->sample_rate);

  357.     jack_info ("netjack: audio    : cap: %d / pbk: %d)", netj->capture_channels_audio, netj->playback_channels_audio);

  358.     jack_info ("netjack: midi     : cap: %d / pbk: %d)", netj->capture_channels_midi, netj->playback_channels_midi);

  359.     jack_info ("netjack: buffsize : rx: %d)", netj->rx_bufsize);

  360.     return (jack_driver_t *) driver;

  361. }

  362. 

  363. /* DRIVER "PLUGIN" INTERFACE */

  364. 

  365. jack_driver_desc_t *

  366. driver_get_descriptor ()

  367. {

  368.     jack_driver_desc_t * desc;

  369.     jack_driver_param_desc_t * params;

  370.     unsigned int i;

  371. 

  372.     desc = calloc (1, sizeof (jack_driver_desc_t));

  373.     strcpy (desc->name, "net");

  374.     desc->nparams = 17;

  375. 

  376.     params = calloc (desc->nparams, sizeof (jack_driver_param_desc_t));

  377. 

  378.     i = 0;

  379.     strcpy (params[i].name, "inchannels");

  380.     params[i].character  = 'i';

  381.     params[i].type       = JackDriverParamUInt;

  382.     params[i].value.ui   = 2U;

  383.     strcpy (params[i].short_desc, "Number of capture channels (defaults to 2)");

  384.     strcpy (params[i].long_desc, params[i].short_desc);

  385. 

  386.     i++;

  387.     strcpy (params[i].name, "outchannels");

  388.     params[i].character  = 'o';

  389.     params[i].type       = JackDriverParamUInt;

  390.     params[i].value.ui   = 2U;

  391.     strcpy (params[i].short_desc, "Number of playback channels (defaults to 2)");

  392.     strcpy (params[i].long_desc, params[i].short_desc);

  393. 

  394.     i++;

  395.     strcpy (params[i].name, "midi inchannels");

  396.     params[i].character  = 'I';

  397.     params[i].type       = JackDriverParamUInt;

  398.     params[i].value.ui   = 1U;

  399.     strcpy (params[i].short_desc, "Number of midi capture channels (defaults to 1)");

  400.     strcpy (params[i].long_desc, params[i].short_desc);

  401. 

  402.     i++;

  403.     strcpy (params[i].name, "midi outchannels");

  404.     params[i].character  = 'O';

  405.     params[i].type       = JackDriverParamUInt;

  406.     params[i].value.ui   = 1U;

  407.     strcpy (params[i].short_desc, "Number of midi playback channels (defaults to 1)");

  408.     strcpy (params[i].long_desc, params[i].short_desc);

  409. 

  410.     i++;

  411.     strcpy (params[i].name, "rate");

  412.     params[i].character  = 'r';

  413.     params[i].type       = JackDriverParamUInt;

  414.     params[i].value.ui   = 48000U;

  415.     strcpy (params[i].short_desc, "Sample rate");

  416.     strcpy (params[i].long_desc, params[i].short_desc);

  417. 

  418.     i++;

  419.     strcpy (params[i].name, "period");

  420.     params[i].character  = 'p';

  421.     params[i].type       = JackDriverParamUInt;

  422.     params[i].value.ui   = 1024U;

  423.     strcpy (params[i].short_desc, "Frames per period");

  424.     strcpy (params[i].long_desc, params[i].short_desc);

  425. 

  426.     i++;

  427.     strcpy (params[i].name, "listen-port");

  428.     params[i].character  = 'l';

  429.     params[i].type       = JackDriverParamUInt;

  430.     params[i].value.ui   = 3000U;

  431.     strcpy (params[i].short_desc,

  432.             "The socket port we are listening on for sync packets");

  433.     strcpy (params[i].long_desc, params[i].short_desc);

  434. 

  435.     i++;

  436.     strcpy (params[i].name, "factor");

  437.     params[i].character  = 'f';

  438.     params[i].type       = JackDriverParamUInt;

  439.     params[i].value.ui   = 1U;

  440.     strcpy (params[i].short_desc,

  441.             "Factor for sample rate reduction");

  442.     strcpy (params[i].long_desc, params[i].short_desc);

  443. 

  444.     i++;

  445.     strcpy (params[i].name, "upstream-factor");

  446.     params[i].character  = 'u';

  447.     params[i].type       = JackDriverParamUInt;

  448.     params[i].value.ui   = 0U;

  449.     strcpy (params[i].short_desc,

  450.             "Factor for sample rate reduction on the upstream");

  451.     strcpy (params[i].long_desc, params[i].short_desc);

  452. 

  453.     i++;

  454.     strcpy (params[i].name, "celt");

  455.     params[i].character  = 'c';

  456.     params[i].type       = JackDriverParamUInt;

  457.     params[i].value.ui   = 0U;

  458.     strcpy (params[i].short_desc,

  459.             "sets celt encoding and number of bytes per channel");

  460.     strcpy (params[i].long_desc, params[i].short_desc);

  461. 

  462.     i++;

  463.     strcpy (params[i].name, "bit-depth");

  464.     params[i].character  = 'b';

  465.     params[i].type       = JackDriverParamUInt;

  466.     params[i].value.ui   = 0U;

  467.     strcpy (params[i].short_desc,

  468.             "Sample bit-depth (0 for float, 8 for 8bit and 16 for 16bit)");

  469.     strcpy (params[i].long_desc, params[i].short_desc);

  470. 

  471.     i++;

  472.     strcpy (params[i].name, "transport-sync");

  473.     params[i].character  = 't';

  474.     params[i].type       = JackDriverParamUInt;

  475.     params[i].value.ui   = 1U;

  476.     strcpy (params[i].short_desc,

  477.             "Whether to slave the transport to the master transport");

  478.     strcpy (params[i].long_desc, params[i].short_desc);

  479. 

  480.     i++;

  481.     strcpy (params[i].name, "autoconf");

  482.     params[i].character  = 'a';

  483.     params[i].type       = JackDriverParamUInt;

  484.     params[i].value.ui   = 1U;

  485.     strcpy (params[i].short_desc,

  486.             "Whether to use Autoconfig, or just start.");

  487.     strcpy (params[i].long_desc, params[i].short_desc);

  488. 

  489.     i++;

  490.     strcpy (params[i].name, "latency");

  491.     params[i].character  = 'L';

  492.     params[i].type       = JackDriverParamUInt;

  493.     params[i].value.ui   = 5U;

  494.     strcpy (params[i].short_desc,

  495.             "Latency setting");

  496.     strcpy (params[i].long_desc, params[i].short_desc);

  497. 

  498.     i++;

  499.     strcpy (params[i].name, "redundancy");

  500.     params[i].character  = 'R';

  501.     params[i].type       = JackDriverParamUInt;

  502.     params[i].value.ui   = 1U;

  503.     strcpy (params[i].short_desc,

  504.             "Send packets N times");

  505.     strcpy (params[i].long_desc, params[i].short_desc);

  506. 

  507.     i++;

  508.     strcpy (params[i].name, "no-htonl");

  509.     params[i].character  = 'H';

  510.     params[i].type       = JackDriverParamUInt;

  511.     params[i].value.ui   = 0U;

  512.     strcpy (params[i].short_desc,

  513.             "Dont convert samples to network byte order.");

  514.     strcpy (params[i].long_desc, params[i].short_desc);

  515. 

  516.     i++;

  517.     strcpy (params[i].name, "always-deadline");

  518.     params[i].character  = 'D';

  519.     params[i].type       = JackDriverParamUInt;

  520.     params[i].value.ui   = 0U;

  521.     strcpy (params[i].short_desc,

  522.             "Always wait until deadline");

  523.     strcpy (params[i].long_desc, params[i].short_desc);

  524.     desc->params = params;

  525. 

  526.     return desc;

  527. }

  528. 

  529. const char driver_client_name[] = "net_pcm";

  530. 

  531. jack_driver_t *

  532. driver_initialize (jack_client_t *client, const JSList * params)

  533. {

  534.     jack_nframes_t sample_rate = 48000;

  535.     jack_nframes_t resample_factor = 1;

  536.     jack_nframes_t period_size = 1024;

  537.     unsigned int capture_ports = 2;

  538.     unsigned int playback_ports = 2;

  539.     unsigned int capture_ports_midi = 1;

  540.     unsigned int playback_ports_midi = 1;

  541.     unsigned int listen_port = 3000;

  542.     unsigned int resample_factor_up = 0;

  543.     unsigned int bitdepth = 0;

  544.     unsigned int handle_transport_sync = 1;

  545.     unsigned int use_autoconfig = 1;

  546.     unsigned int latency = 5;

  547.     unsigned int redundancy = 1;

  548.     int dont_htonl_floats = 0;

  549.     int always_deadline = 0;

  550.     const JSList * node;

  551.     const jack_driver_param_t * param;

  552. 

  553.     for (node = params; node; node = jack_slist_next (node)) {

  554.         param = (const jack_driver_param_t *) node->data;

  555. 

  556.         switch (param->character) {

  557. 

  558.             case 'i':

  559.                 capture_ports = param->value.ui;

  560.                 break;

  561. 

  562.             case 'o':

  563.                 playback_ports = param->value.ui;

  564.                 break;

  565. 

  566.             case 'I':

  567.                 capture_ports_midi = param->value.ui;

  568.                 break;

  569. 

  570.             case 'O':

  571.                 playback_ports_midi = param->value.ui;

  572.                 break;

  573. 

  574.             case 'r':

  575.                 sample_rate = param->value.ui;

  576.                 break;

  577. 

  578.             case 'p':

  579.                 period_size = param->value.ui;

  580.                 break;

  581. 

  582.             case 'l':

  583.                 listen_port = param->value.ui;

  584.                 break;

  585. 

  586.             case 'f':

  587. #if HAVE_SAMPLERATE

  588.                 resample_factor = param->value.ui;

  589. #else

  590. 		printf( "not built with libsamplerate support\n" );

  591. 		exit(10);

  592. #endif

  593.                 break;

  594. 

  595.             case 'u':

  596. #if HAVE_SAMPLERATE

  597.                 resample_factor_up = param->value.ui;

  598. #else

  599. 		printf( "not built with libsamplerate support\n" );

  600. 		exit(10);

  601. #endif

  602.                 break;

  603. 

  604.             case 'b':

  605.                 bitdepth = param->value.ui;

  606.                 break;

  607. 

  608. 	    case 'c':

  609. #if HAVE_CELT

  610. 		bitdepth = 1000;

  611. 		resample_factor = param->value.ui;

  612. #else

  613. 		printf( "not built with celt support\n" );

  614. 		exit(10);

  615. #endif

  616. 		break;

  617. 

  618.             case 't':

  619.                 handle_transport_sync = param->value.ui;

  620.                 break;

  621. 

  622.             case 'a':

  623.                 use_autoconfig = param->value.ui;

  624.                 break;

  625. 

  626.             case 'L':

  627.                 latency = param->value.ui;

  628.                 break;

  629. 

  630.             case 'R':

  631.                 redundancy = param->value.ui;

  632.                 break;

  633. 

  634.             case 'H':

  635.                 dont_htonl_floats = param->value.ui;

  636.                 break;

  637.             case 'D':

  638.                 always_deadline = param->value.ui;

  639.                 break;

  640.         }

  641.     }

  642. 

  643.     return net_driver_new (client, "net_pcm", capture_ports, playback_ports,

  644.                            capture_ports_midi, playback_ports_midi,

  645.                            sample_rate, period_size,

  646.                            listen_port, handle_transport_sync,

  647.                            resample_factor, resample_factor_up, bitdepth,

  648. 			   use_autoconfig, latency, redundancy,

  649. 			   dont_htonl_floats, always_deadline);

  650. }

  651. 

  652. void

  653. driver_finish (jack_driver_t *driver)

  654. {

  655.     net_driver_delete ((net_driver_t *) driver);

  656. }