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

661 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. 

  62.     if( netjack_wait( netj ) ) {

  63. 	    driver->engine->delay( driver->engine, 0 );

  64.     }

  65. 

  66.     

  67.     driver->last_wait_ust = jack_get_microseconds ();

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

  69. 

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

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

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

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

  74.     *status = 0;

  75.     return netj->period_size;

  76. }

  77. 

  78. static int

  79. net_driver_run_cycle (net_driver_t *driver)

  80. {

  81.     jack_engine_t *engine = driver->engine;

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

  83.     int wait_status = -1;

  84.     float delayed_usecs;

  85. 

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

  87.                              &delayed_usecs);

  88. 

  89.     // XXX: xrun code removed.

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

  91.     //      things are different on the net.

  92. 

  93.     if (wait_status == 0)

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

  95. 

  96.     if (wait_status < 0)

  97.         return -1;

  98.     else

  99.         return 0;

  100. }

  101. 

  102. static int

  103. net_driver_null_cycle (net_driver_t* driver, jack_nframes_t nframes)

  104. {

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

  106.     //       do i wait here ?

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

  108. 

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

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

  111.     netjack_send_silence( netj, sync_state );

  112. 

  113.     return 0;

  114. }

  115. 

  116. static int

  117. net_driver_bufsize (net_driver_t* driver, jack_nframes_t nframes)

  118. {

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

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

  121.         return EINVAL;

  122. 

  123.     return 0;

  124. }

  125. 

  126. static int

  127. net_driver_read (net_driver_t* driver, jack_nframes_t nframes)

  128. {

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

  130. 

  131.     jack_position_t local_trans_pos;

  132.     jack_transport_state_t local_trans_state;

  133. 

  134.     unsigned int *packet_buf, *packet_bufX;

  135. 

  136.     if( ! netj->packet_data_valid ) {

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

  138. 	return 0;

  139.     }

  140.     packet_buf = netj->rx_buf;

  141. 

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

  143. 

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

  145. 

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

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

  148. 

  149.     // Special handling for latency=0

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

  151. 	netj->resync_threshold = 0;

  152.     else

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

  154. 

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

  156.     if (netj->handle_transport_sync) {

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

  158. 

  159.         // read local transport info....

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

  161. 

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

  163.         switch (pkthdr->transport_state) {

  164.             case JackTransportStarting:

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

  166.                 if (local_trans_state == JackTransportStopped) {

  167.                     jack_transport_start(netj->client);

  168.                     last_transport_state = JackTransportStopped;

  169.                     sync_state = FALSE;

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

  171.                 }

  172. 

  173.                 if (local_trans_pos.frame != compensated_tranport_pos)

  174. 		{

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

  176.                     last_transport_state = JackTransportRolling;

  177.                     sync_state = FALSE;

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

  179.                 }

  180.                 break;

  181.             case JackTransportStopped:

  182.                 sync_state = TRUE;

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

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

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

  186.                 }

  187.                 if (local_trans_state != JackTransportStopped)

  188.                     jack_transport_stop(netj->client);

  189.                 break;

  190.             case JackTransportRolling:

  191.                 sync_state = TRUE;

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

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

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

  195. //		    		}

  196.                 if (local_trans_state != JackTransportRolling)

  197.                     jack_transport_start (netj->client);

  198.                 break;

  199. 

  200.             case JackTransportLooping:

  201.                 break;

  202.         }

  203.     }

  204. 

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

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

  207. 

  208.     return 0;

  209. }

  210. 

  211. static int

  212. net_driver_write (net_driver_t* driver, jack_nframes_t nframes)

  213. {

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

  215. 

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

  217. 

  218.     uint32_t *packet_buf, *packet_bufX;

  219. 

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

  221.     jacknet_packet_header *pkthdr; 

  222. 

  223.     packet_buf = alloca(packet_size);

  224.     pkthdr = (jacknet_packet_header *)packet_buf;

  225. 

  226.     if( netj->running_free ) {

  227. 	return 0;

  228.     }

  229. 

  230.     // offset packet_bufX by the packetheader.

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

  232. 

  233.     pkthdr->sync_state = sync_state;

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

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

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

  237. 

  238. 

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

  240. 

  241.     packet_header_hton(pkthdr);

  242.     if (netj->srcaddress_valid)

  243.     {

  244. 	int r;

  245. 

  246. #ifndef MSG_CONFIRM

  247. 	static const int flag = 0;

  248. #else

  249. 	static const int flag = MSG_CONFIRM;

  250. #endif

  251. 

  252.         if (netj->reply_port)

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

  254. 

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

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

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

  258.     }

  259. 

  260.     return 0;

  261. }

  262. 

  263. 

  264. static int

  265. net_driver_attach (net_driver_t *driver)

  266. {

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

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

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

  270. 

  271.     netjack_attach( netj );

  272.     return 0;

  273. }

  274. 

  275. static int

  276. net_driver_detach (net_driver_t *driver)

  277. {

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

  279. 

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

  281.         return 0;

  282. 

  283.     netjack_detach( netj );

  284.     return 0;

  285. }

  286. 

  287. static void

  288. net_driver_delete (net_driver_t *driver)

  289. {

  290.     jack_driver_nt_finish ((jack_driver_nt_t *) driver);

  291.     free (driver);

  292. }

  293. 

  294. static jack_driver_t *

  295. net_driver_new (jack_client_t * client,

  296.                 char *name,

  297.                 unsigned int capture_ports,

  298.                 unsigned int playback_ports,

  299.                 unsigned int capture_ports_midi,

  300.                 unsigned int playback_ports_midi,

  301.                 jack_nframes_t sample_rate,

  302.                 jack_nframes_t period_size,

  303.                 unsigned int listen_port,

  304.                 unsigned int transport_sync,

  305.                 unsigned int resample_factor,

  306.                 unsigned int resample_factor_up,

  307.                 unsigned int bitdepth,

  308. 		unsigned int use_autoconfig,

  309. 		unsigned int latency,

  310. 		unsigned int redundancy,

  311. 		int dont_htonl_floats,

  312. 		int always_deadline)

  313. {

  314.     net_driver_t * driver;

  315. 

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

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

  318.             capture_ports, playback_ports, transport_sync);

  319. 

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

  321. 

  322.     jack_driver_nt_init ((jack_driver_nt_t *) driver);

  323. 

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

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

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

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

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

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

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

  331. 

  332.     driver->last_wait_ust = 0;

  333.     driver->engine = NULL;

  334. 

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

  336. 

  337.     netjack_init ( netj,

  338. 		client,

  339.                 name,

  340.                 capture_ports,

  341.                 playback_ports,

  342.                 capture_ports_midi,

  343.                 playback_ports_midi,

  344.                 sample_rate,

  345.                 period_size,

  346.                 listen_port,

  347.                 transport_sync,

  348.                 resample_factor,

  349.                 resample_factor_up,

  350.                 bitdepth,

  351. 		use_autoconfig,

  352. 		latency,

  353. 		redundancy,

  354. 		dont_htonl_floats,

  355. 	        always_deadline	);

  356. 

  357.     netjack_startup( netj );

  358. 

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

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

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

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

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

  364.     return (jack_driver_t *) driver;

  365. }

  366. 

  367. /* DRIVER "PLUGIN" INTERFACE */

  368. 

  369. jack_driver_desc_t *

  370. driver_get_descriptor ()

  371. {

  372.     jack_driver_desc_t * desc;

  373.     jack_driver_param_desc_t * params;

  374.     unsigned int i;

  375. 

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

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

  378.     desc->nparams = 17;

  379. 

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

  381. 

  382.     i = 0;

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

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

  385.     params[i].type       = JackDriverParamUInt;

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

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

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

  389. 

  390.     i++;

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

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

  393.     params[i].type       = JackDriverParamUInt;

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

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

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

  397. 

  398.     i++;

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

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

  401.     params[i].type       = JackDriverParamUInt;

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

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

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

  405. 

  406.     i++;

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

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

  409.     params[i].type       = JackDriverParamUInt;

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

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

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

  413. 

  414.     i++;

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

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

  417.     params[i].type       = JackDriverParamUInt;

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

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

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

  421. 

  422.     i++;

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

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

  425.     params[i].type       = JackDriverParamUInt;

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

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

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

  429. 

  430.     i++;

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

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

  433.     params[i].type       = JackDriverParamUInt;

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

  435.     strcpy (params[i].short_desc,

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

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

  438. 

  439.     i++;

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

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

  442.     params[i].type       = JackDriverParamUInt;

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

  444.     strcpy (params[i].short_desc,

  445.             "Factor for sample rate reduction");

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

  447. 

  448.     i++;

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

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

  451.     params[i].type       = JackDriverParamUInt;

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

  453.     strcpy (params[i].short_desc,

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

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

  456. 

  457.     i++;

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

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

  460.     params[i].type       = JackDriverParamUInt;

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

  462.     strcpy (params[i].short_desc,

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

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

  465. 

  466.     i++;

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

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

  469.     params[i].type       = JackDriverParamUInt;

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

  471.     strcpy (params[i].short_desc,

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

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

  474. 

  475.     i++;

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

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

  478.     params[i].type       = JackDriverParamUInt;

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

  480.     strcpy (params[i].short_desc,

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

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

  483. 

  484.     i++;

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

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

  487.     params[i].type       = JackDriverParamUInt;

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

  489.     strcpy (params[i].short_desc,

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

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

  492. 

  493.     i++;

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

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

  496.     params[i].type       = JackDriverParamUInt;

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

  498.     strcpy (params[i].short_desc,

  499.             "Latency setting");

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

  501. 

  502.     i++;

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

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

  505.     params[i].type       = JackDriverParamUInt;

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

  507.     strcpy (params[i].short_desc,

  508.             "Send packets N times");

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

  510. 

  511.     i++;

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

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

  514.     params[i].type       = JackDriverParamUInt;

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

  516.     strcpy (params[i].short_desc,

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

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

  519. 

  520.     i++;

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

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

  523.     params[i].type       = JackDriverParamUInt;

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

  525.     strcpy (params[i].short_desc,

  526.             "Always wait until deadline");

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

  528.     desc->params = params;

  529. 

  530.     return desc;

  531. }

  532. 

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

  534. 

  535. jack_driver_t *

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

  537. {

  538.     jack_nframes_t sample_rate = 48000;

  539.     jack_nframes_t resample_factor = 1;

  540.     jack_nframes_t period_size = 1024;

  541.     unsigned int capture_ports = 2;

  542.     unsigned int playback_ports = 2;

  543.     unsigned int capture_ports_midi = 1;

  544.     unsigned int playback_ports_midi = 1;

  545.     unsigned int listen_port = 3000;

  546.     unsigned int resample_factor_up = 0;

  547.     unsigned int bitdepth = 0;

  548.     unsigned int handle_transport_sync = 1;

  549.     unsigned int use_autoconfig = 1;

  550.     unsigned int latency = 5;

  551.     unsigned int redundancy = 1;

  552.     int dont_htonl_floats = 0;

  553.     int always_deadline = 0;

  554.     const JSList * node;

  555.     const jack_driver_param_t * param;

  556. 

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

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

  559. 

  560.         switch (param->character) {

  561. 

  562.             case 'i':

  563.                 capture_ports = param->value.ui;

  564.                 break;

  565. 

  566.             case 'o':

  567.                 playback_ports = param->value.ui;

  568.                 break;

  569. 

  570.             case 'I':

  571.                 capture_ports_midi = param->value.ui;

  572.                 break;

  573. 

  574.             case 'O':

  575.                 playback_ports_midi = param->value.ui;

  576.                 break;

  577. 

  578.             case 'r':

  579.                 sample_rate = param->value.ui;

  580.                 break;

  581. 

  582.             case 'p':

  583.                 period_size = param->value.ui;

  584.                 break;

  585. 

  586.             case 'l':

  587.                 listen_port = param->value.ui;

  588.                 break;

  589. 

  590.             case 'f':

  591. #if HAVE_SAMPLERATE

  592.                 resample_factor = param->value.ui;

  593. #else

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

  595. 		exit(10);

  596. #endif

  597.                 break;

  598. 

  599.             case 'u':

  600. #if HAVE_SAMPLERATE

  601.                 resample_factor_up = param->value.ui;

  602. #else

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

  604. 		exit(10);

  605. #endif

  606.                 break;

  607. 

  608.             case 'b':

  609.                 bitdepth = param->value.ui;

  610.                 break;

  611. 

  612. 	    case 'c':

  613. #if HAVE_CELT

  614. 		bitdepth = 1000;

  615. 		resample_factor = param->value.ui;

  616. #else

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

  618. 		exit(10);

  619. #endif

  620. 		break;

  621. 

  622.             case 't':

  623.                 handle_transport_sync = param->value.ui;

  624.                 break;

  625. 

  626.             case 'a':

  627.                 use_autoconfig = param->value.ui;

  628.                 break;

  629. 

  630.             case 'L':

  631.                 latency = param->value.ui;

  632.                 break;

  633. 

  634.             case 'R':

  635.                 redundancy = param->value.ui;

  636.                 break;

  637. 

  638.             case 'H':

  639.                 dont_htonl_floats = param->value.ui;

  640.                 break;

  641.             case 'D':

  642.                 always_deadline = param->value.ui;

  643.                 break;

  644.         }

  645.     }

  646. 

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

  648.                            capture_ports_midi, playback_ports_midi,

  649.                            sample_rate, period_size,

  650.                            listen_port, handle_transport_sync,

  651.                            resample_factor, resample_factor_up, bitdepth,

  652. 			   use_autoconfig, latency, redundancy,

  653. 			   dont_htonl_floats, always_deadline);

  654. }

  655. 

  656. void

  657. driver_finish (jack_driver_t *driver)

  658. {

  659.     net_driver_delete ((net_driver_t *) driver);

  660. }