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.
1143 Commits
4 Branches
14MB
Tree: 43e32d389a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '43e32d389a'
${ noResults }
jack1/drivers/netjack/net_driver.c

666 lines
21KB
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.     int delay;

  62. 

  63.     delay = netjack_wait( netj );

  64.     if( delay ) {

  65. 	    //driver->engine->delay( driver->engine, (float)delay );

  66. 	    jack_error( "netxruns amount: %dms", delay/1000 );

  67.     }

  68. 

  69.     

  70.     driver->last_wait_ust = jack_get_microseconds ();

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

  72. 

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

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

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

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

  77.     *status = 0;

  78.     return netj->period_size;

  79. }

  80. 

  81. static int

  82. net_driver_run_cycle (net_driver_t *driver)

  83. {

  84.     jack_engine_t *engine = driver->engine;

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

  86.     int wait_status = -1;

  87.     float delayed_usecs;

  88. 

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

  90.                              &delayed_usecs);

  91. 

  92.     // XXX: xrun code removed.

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

  94.     //      things are different on the net.

  95. 

  96.     if (wait_status == 0)

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

  98. 

  99.     if (wait_status < 0)

  100.         return -1;

  101.     else

  102.         return 0;

  103. }

  104. 

  105. static int

  106. net_driver_null_cycle (net_driver_t* driver, jack_nframes_t nframes)

  107. {

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

  109.     //       do i wait here ?

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

  111. 

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

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

  114.     netjack_send_silence( netj, sync_state );

  115. 

  116.     return 0;

  117. }

  118. 

  119. static int

  120. net_driver_bufsize (net_driver_t* driver, jack_nframes_t nframes)

  121. {

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

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

  124.         return EINVAL;

  125. 

  126.     return 0;

  127. }

  128. 

  129. static int

  130. net_driver_read (net_driver_t* driver, jack_nframes_t nframes)

  131. {

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

  133. 

  134.     jack_position_t local_trans_pos;

  135.     jack_transport_state_t local_trans_state;

  136. 

  137.     unsigned int *packet_buf, *packet_bufX;

  138. 

  139.     if( ! netj->packet_data_valid ) {

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

  141. 	return 0;

  142.     }

  143.     packet_buf = netj->rx_buf;

  144. 

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

  146. 

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

  148. 

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

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

  151. 

  152.     // Special handling for latency=0

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

  154. 	netj->resync_threshold = 0;

  155.     else

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

  157. 

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

  159.     if (netj->handle_transport_sync) {

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

  161. 

  162.         // read local transport info....

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

  164. 

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

  166.         switch (pkthdr->transport_state) {

  167.             case JackTransportStarting:

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

  169.                 if (local_trans_state == JackTransportStopped) {

  170.                     jack_transport_start(netj->client);

  171.                     last_transport_state = JackTransportStopped;

  172.                     sync_state = FALSE;

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

  174.                 }

  175. 

  176.                 if (local_trans_pos.frame != compensated_tranport_pos)

  177. 		{

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

  179.                     last_transport_state = JackTransportRolling;

  180.                     sync_state = FALSE;

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

  182.                 }

  183.                 break;

  184.             case JackTransportStopped:

  185.                 sync_state = TRUE;

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

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

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

  189.                 }

  190.                 if (local_trans_state != JackTransportStopped)

  191.                     jack_transport_stop(netj->client);

  192.                 break;

  193.             case JackTransportRolling:

  194.                 sync_state = TRUE;

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

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

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

  198. //		    		}

  199.                 if (local_trans_state != JackTransportRolling)

  200.                     jack_transport_start (netj->client);

  201.                 break;

  202. 

  203.             case JackTransportLooping:

  204.                 break;

  205.         }

  206.     }

  207. 

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

  209.     packet_cache_release_packet(global_packcache, netj->expected_framecnt );

  210. 

  211.     return 0;

  212. }

  213. 

  214. static int

  215. net_driver_write (net_driver_t* driver, jack_nframes_t nframes)

  216. {

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

  218. 

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

  220. 

  221.     uint32_t *packet_buf, *packet_bufX;

  222. 

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

  224.     jacknet_packet_header *pkthdr; 

  225. 

  226.     packet_buf = alloca(packet_size);

  227.     pkthdr = (jacknet_packet_header *)packet_buf;

  228. 

  229.     if( netj->running_free ) {

  230. 	return 0;

  231.     }

  232. 

  233.     // offset packet_bufX by the packetheader.

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

  235. 

  236.     pkthdr->sync_state = sync_state;

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

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

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

  240. 

  241. 

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

  243. 

  244.     packet_header_hton(pkthdr);

  245.     if (netj->srcaddress_valid)

  246.     {

  247. 	int r;

  248. 

  249. #ifndef MSG_CONFIRM

  250. 	static const int flag = 0;

  251. #else

  252. 	static const int flag = MSG_CONFIRM;

  253. #endif

  254. 

  255.         if (netj->reply_port)

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

  257. 

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

  259. 	    netjack_sendto(netj->sockfd, (char *)packet_buf, packet_size,

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

  261.     }

  262. 

  263.     return 0;

  264. }

  265. 

  266. 

  267. static int

  268. net_driver_attach (net_driver_t *driver)

  269. {

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

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

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

  273. 

  274.     netjack_attach( netj );

  275.     return 0;

  276. }

  277. 

  278. static int

  279. net_driver_detach (net_driver_t *driver)

  280. {

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

  282. 

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

  284.         return 0;

  285. 

  286.     netjack_detach( netj );

  287.     return 0;

  288. }

  289. 

  290. static void

  291. net_driver_delete (net_driver_t *driver)

  292. {

  293.     jack_driver_nt_finish ((jack_driver_nt_t *) driver);

  294.     free (driver);

  295. }

  296. 

  297. static jack_driver_t *

  298. net_driver_new (jack_client_t * client,

  299.                 char *name,

  300.                 unsigned int capture_ports,

  301.                 unsigned int playback_ports,

  302.                 unsigned int capture_ports_midi,

  303.                 unsigned int playback_ports_midi,

  304.                 jack_nframes_t sample_rate,

  305.                 jack_nframes_t period_size,

  306.                 unsigned int listen_port,

  307.                 unsigned int transport_sync,

  308.                 unsigned int resample_factor,

  309.                 unsigned int resample_factor_up,

  310.                 unsigned int bitdepth,

  311. 		unsigned int use_autoconfig,

  312. 		unsigned int latency,

  313. 		unsigned int redundancy,

  314. 		int dont_htonl_floats,

  315. 		int always_deadline)

  316. {

  317.     net_driver_t * driver;

  318. 

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

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

  321.             capture_ports, playback_ports, transport_sync);

  322. 

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

  324. 

  325.     jack_driver_nt_init ((jack_driver_nt_t *) driver);

  326. 

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

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

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

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

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

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

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

  334. 

  335.     driver->last_wait_ust = 0;

  336.     driver->engine = NULL;

  337. 

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

  339. 

  340.     netjack_init ( netj,

  341. 		client,

  342.                 name,

  343.                 capture_ports,

  344.                 playback_ports,

  345.                 capture_ports_midi,

  346.                 playback_ports_midi,

  347.                 sample_rate,

  348.                 period_size,

  349.                 listen_port,

  350.                 transport_sync,

  351.                 resample_factor,

  352.                 resample_factor_up,

  353.                 bitdepth,

  354. 		use_autoconfig,

  355. 		latency,

  356. 		redundancy,

  357. 		dont_htonl_floats,

  358. 	        always_deadline	);

  359. 

  360.     netjack_startup( netj );

  361. 

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

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

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

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

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

  367.     driver->period_usecs = netj->period_usecs;

  368. 

  369.     return (jack_driver_t *) driver;

  370. }

  371. 

  372. /* DRIVER "PLUGIN" INTERFACE */

  373. 

  374. jack_driver_desc_t *

  375. driver_get_descriptor ()

  376. {

  377.     jack_driver_desc_t * desc;

  378.     jack_driver_param_desc_t * params;

  379.     unsigned int i;

  380. 

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

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

  383.     desc->nparams = 17;

  384. 

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

  386. 

  387.     i = 0;

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

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

  390.     params[i].type       = JackDriverParamUInt;

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

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

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

  394. 

  395.     i++;

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

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

  398.     params[i].type       = JackDriverParamUInt;

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

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

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

  402. 

  403.     i++;

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

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

  406.     params[i].type       = JackDriverParamUInt;

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

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

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

  410. 

  411.     i++;

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

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

  414.     params[i].type       = JackDriverParamUInt;

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

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

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

  418. 

  419.     i++;

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

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

  422.     params[i].type       = JackDriverParamUInt;

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

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

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

  426. 

  427.     i++;

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

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

  430.     params[i].type       = JackDriverParamUInt;

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

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

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

  434. 

  435.     i++;

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

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

  438.     params[i].type       = JackDriverParamUInt;

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

  440.     strcpy (params[i].short_desc,

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

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

  443. 

  444.     i++;

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

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

  447.     params[i].type       = JackDriverParamUInt;

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

  449.     strcpy (params[i].short_desc,

  450.             "Factor for sample rate reduction");

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

  452. 

  453.     i++;

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

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

  456.     params[i].type       = JackDriverParamUInt;

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

  458.     strcpy (params[i].short_desc,

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

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

  461. 

  462.     i++;

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

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

  465.     params[i].type       = JackDriverParamUInt;

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

  467.     strcpy (params[i].short_desc,

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

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

  470. 

  471.     i++;

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

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

  474.     params[i].type       = JackDriverParamUInt;

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

  476.     strcpy (params[i].short_desc,

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

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

  479. 

  480.     i++;

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

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

  483.     params[i].type       = JackDriverParamUInt;

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

  485.     strcpy (params[i].short_desc,

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

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

  488. 

  489.     i++;

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

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

  492.     params[i].type       = JackDriverParamUInt;

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

  494.     strcpy (params[i].short_desc,

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

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

  497. 

  498.     i++;

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

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

  501.     params[i].type       = JackDriverParamUInt;

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

  503.     strcpy (params[i].short_desc,

  504.             "Latency setting");

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

  506. 

  507.     i++;

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

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

  510.     params[i].type       = JackDriverParamUInt;

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

  512.     strcpy (params[i].short_desc,

  513.             "Send packets N times");

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

  515. 

  516.     i++;

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

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

  519.     params[i].type       = JackDriverParamUInt;

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

  521.     strcpy (params[i].short_desc,

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

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

  524. 

  525.     i++;

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

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

  528.     params[i].type       = JackDriverParamUInt;

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

  530.     strcpy (params[i].short_desc,

  531.             "Always wait until deadline");

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

  533.     desc->params = params;

  534. 

  535.     return desc;

  536. }

  537. 

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

  539. 

  540. jack_driver_t *

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

  542. {

  543.     jack_nframes_t sample_rate = 48000;

  544.     jack_nframes_t resample_factor = 1;

  545.     jack_nframes_t period_size = 1024;

  546.     unsigned int capture_ports = 2;

  547.     unsigned int playback_ports = 2;

  548.     unsigned int capture_ports_midi = 1;

  549.     unsigned int playback_ports_midi = 1;

  550.     unsigned int listen_port = 3000;

  551.     unsigned int resample_factor_up = 0;

  552.     unsigned int bitdepth = 0;

  553.     unsigned int handle_transport_sync = 1;

  554.     unsigned int use_autoconfig = 1;

  555.     unsigned int latency = 5;

  556.     unsigned int redundancy = 1;

  557.     int dont_htonl_floats = 0;

  558.     int always_deadline = 0;

  559.     const JSList * node;

  560.     const jack_driver_param_t * param;

  561. 

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

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

  564. 

  565.         switch (param->character) {

  566. 

  567.             case 'i':

  568.                 capture_ports = param->value.ui;

  569.                 break;

  570. 

  571.             case 'o':

  572.                 playback_ports = param->value.ui;

  573.                 break;

  574. 

  575.             case 'I':

  576.                 capture_ports_midi = param->value.ui;

  577.                 break;

  578. 

  579.             case 'O':

  580.                 playback_ports_midi = param->value.ui;

  581.                 break;

  582. 

  583.             case 'r':

  584.                 sample_rate = param->value.ui;

  585.                 break;

  586. 

  587.             case 'p':

  588.                 period_size = param->value.ui;

  589.                 break;

  590. 

  591.             case 'l':

  592.                 listen_port = param->value.ui;

  593.                 break;

  594. 

  595.             case 'f':

  596. #if HAVE_SAMPLERATE

  597.                 resample_factor = param->value.ui;

  598. #else

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

  600. 		exit(10);

  601. #endif

  602.                 break;

  603. 

  604.             case 'u':

  605. #if HAVE_SAMPLERATE

  606.                 resample_factor_up = param->value.ui;

  607. #else

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

  609. 		exit(10);

  610. #endif

  611.                 break;

  612. 

  613.             case 'b':

  614.                 bitdepth = param->value.ui;

  615.                 break;

  616. 

  617. 	    case 'c':

  618. #if HAVE_CELT

  619. 		bitdepth = 1000;

  620. 		resample_factor = param->value.ui;

  621. #else

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

  623. 		exit(10);

  624. #endif

  625. 		break;

  626. 

  627.             case 't':

  628.                 handle_transport_sync = param->value.ui;

  629.                 break;

  630. 

  631.             case 'a':

  632.                 use_autoconfig = param->value.ui;

  633.                 break;

  634. 

  635.             case 'L':

  636.                 latency = param->value.ui;

  637.                 break;

  638. 

  639.             case 'R':

  640.                 redundancy = param->value.ui;

  641.                 break;

  642. 

  643.             case 'H':

  644.                 dont_htonl_floats = param->value.ui;

  645.                 break;

  646.             case 'D':

  647.                 always_deadline = param->value.ui;

  648.                 break;

  649.         }

  650.     }

  651. 

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

  653.                            capture_ports_midi, playback_ports_midi,

  654.                            sample_rate, period_size,

  655.                            listen_port, handle_transport_sync,

  656.                            resample_factor, resample_factor_up, bitdepth,

  657. 			   use_autoconfig, latency, redundancy,

  658. 			   dont_htonl_floats, always_deadline);

  659. }

  660. 

  661. void

  662. driver_finish (jack_driver_t *driver)

  663. {

  664.     net_driver_delete ((net_driver_t *) driver);

  665. }