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

664 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.     return (jack_driver_t *) driver;

  368. }

  369. 

  370. /* DRIVER "PLUGIN" INTERFACE */

  371. 

  372. jack_driver_desc_t *

  373. driver_get_descriptor ()

  374. {

  375.     jack_driver_desc_t * desc;

  376.     jack_driver_param_desc_t * params;

  377.     unsigned int i;

  378. 

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

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

  381.     desc->nparams = 17;

  382. 

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

  384. 

  385.     i = 0;

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

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

  388.     params[i].type       = JackDriverParamUInt;

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

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

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

  392. 

  393.     i++;

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

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

  396.     params[i].type       = JackDriverParamUInt;

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

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

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

  400. 

  401.     i++;

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

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

  404.     params[i].type       = JackDriverParamUInt;

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

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

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

  408. 

  409.     i++;

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

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

  412.     params[i].type       = JackDriverParamUInt;

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

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

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

  416. 

  417.     i++;

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

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

  420.     params[i].type       = JackDriverParamUInt;

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

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

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

  424. 

  425.     i++;

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

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

  428.     params[i].type       = JackDriverParamUInt;

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

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

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

  432. 

  433.     i++;

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

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

  436.     params[i].type       = JackDriverParamUInt;

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

  438.     strcpy (params[i].short_desc,

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

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

  441. 

  442.     i++;

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

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

  445.     params[i].type       = JackDriverParamUInt;

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

  447.     strcpy (params[i].short_desc,

  448.             "Factor for sample rate reduction");

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

  450. 

  451.     i++;

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

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

  454.     params[i].type       = JackDriverParamUInt;

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

  456.     strcpy (params[i].short_desc,

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

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

  459. 

  460.     i++;

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

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

  463.     params[i].type       = JackDriverParamUInt;

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

  465.     strcpy (params[i].short_desc,

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

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

  468. 

  469.     i++;

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

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

  472.     params[i].type       = JackDriverParamUInt;

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

  474.     strcpy (params[i].short_desc,

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

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

  477. 

  478.     i++;

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

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

  481.     params[i].type       = JackDriverParamUInt;

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

  483.     strcpy (params[i].short_desc,

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

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

  486. 

  487.     i++;

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

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

  490.     params[i].type       = JackDriverParamUInt;

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

  492.     strcpy (params[i].short_desc,

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

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

  495. 

  496.     i++;

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

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

  499.     params[i].type       = JackDriverParamUInt;

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

  501.     strcpy (params[i].short_desc,

  502.             "Latency setting");

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

  504. 

  505.     i++;

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

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

  508.     params[i].type       = JackDriverParamUInt;

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

  510.     strcpy (params[i].short_desc,

  511.             "Send packets N times");

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

  513. 

  514.     i++;

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

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

  517.     params[i].type       = JackDriverParamUInt;

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

  519.     strcpy (params[i].short_desc,

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

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

  522. 

  523.     i++;

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

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

  526.     params[i].type       = JackDriverParamUInt;

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

  528.     strcpy (params[i].short_desc,

  529.             "Always wait until deadline");

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

  531.     desc->params = params;

  532. 

  533.     return desc;

  534. }

  535. 

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

  537. 

  538. jack_driver_t *

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

  540. {

  541.     jack_nframes_t sample_rate = 48000;

  542.     jack_nframes_t resample_factor = 1;

  543.     jack_nframes_t period_size = 1024;

  544.     unsigned int capture_ports = 2;

  545.     unsigned int playback_ports = 2;

  546.     unsigned int capture_ports_midi = 1;

  547.     unsigned int playback_ports_midi = 1;

  548.     unsigned int listen_port = 3000;

  549.     unsigned int resample_factor_up = 0;

  550.     unsigned int bitdepth = 0;

  551.     unsigned int handle_transport_sync = 1;

  552.     unsigned int use_autoconfig = 1;

  553.     unsigned int latency = 5;

  554.     unsigned int redundancy = 1;

  555.     int dont_htonl_floats = 0;

  556.     int always_deadline = 0;

  557.     const JSList * node;

  558.     const jack_driver_param_t * param;

  559. 

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

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

  562. 

  563.         switch (param->character) {

  564. 

  565.             case 'i':

  566.                 capture_ports = param->value.ui;

  567.                 break;

  568. 

  569.             case 'o':

  570.                 playback_ports = param->value.ui;

  571.                 break;

  572. 

  573.             case 'I':

  574.                 capture_ports_midi = param->value.ui;

  575.                 break;

  576. 

  577.             case 'O':

  578.                 playback_ports_midi = param->value.ui;

  579.                 break;

  580. 

  581.             case 'r':

  582.                 sample_rate = param->value.ui;

  583.                 break;

  584. 

  585.             case 'p':

  586.                 period_size = param->value.ui;

  587.                 break;

  588. 

  589.             case 'l':

  590.                 listen_port = param->value.ui;

  591.                 break;

  592. 

  593.             case 'f':

  594. #if HAVE_SAMPLERATE

  595.                 resample_factor = param->value.ui;

  596. #else

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

  598. 		exit(10);

  599. #endif

  600.                 break;

  601. 

  602.             case 'u':

  603. #if HAVE_SAMPLERATE

  604.                 resample_factor_up = param->value.ui;

  605. #else

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

  607. 		exit(10);

  608. #endif

  609.                 break;

  610. 

  611.             case 'b':

  612.                 bitdepth = param->value.ui;

  613.                 break;

  614. 

  615. 	    case 'c':

  616. #if HAVE_CELT

  617. 		bitdepth = 1000;

  618. 		resample_factor = param->value.ui;

  619. #else

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

  621. 		exit(10);

  622. #endif

  623. 		break;

  624. 

  625.             case 't':

  626.                 handle_transport_sync = param->value.ui;

  627.                 break;

  628. 

  629.             case 'a':

  630.                 use_autoconfig = param->value.ui;

  631.                 break;

  632. 

  633.             case 'L':

  634.                 latency = param->value.ui;

  635.                 break;

  636. 

  637.             case 'R':

  638.                 redundancy = param->value.ui;

  639.                 break;

  640. 

  641.             case 'H':

  642.                 dont_htonl_floats = param->value.ui;

  643.                 break;

  644.             case 'D':

  645.                 always_deadline = param->value.ui;

  646.                 break;

  647.         }

  648.     }

  649. 

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

  651.                            capture_ports_midi, playback_ports_midi,

  652.                            sample_rate, period_size,

  653.                            listen_port, handle_transport_sync,

  654.                            resample_factor, resample_factor_up, bitdepth,

  655. 			   use_autoconfig, latency, redundancy,

  656. 			   dont_htonl_floats, always_deadline);

  657. }

  658. 

  659. void

  660. driver_finish (jack_driver_t *driver)

  661. {

  662.     net_driver_delete ((net_driver_t *) driver);

  663. }