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

680 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. 		int jitter_val)

  317. {

  318.     net_driver_t * driver;

  319. 

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

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

  322.             capture_ports, playback_ports, transport_sync);

  323. 

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

  325. 

  326.     jack_driver_nt_init ((jack_driver_nt_t *) driver);

  327. 

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

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

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

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

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

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

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

  335. 

  336.     driver->last_wait_ust = 0;

  337.     driver->engine = NULL;

  338. 

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

  340. 

  341.     netjack_init ( netj,

  342. 		client,

  343.                 name,

  344.                 capture_ports,

  345.                 playback_ports,

  346.                 capture_ports_midi,

  347.                 playback_ports_midi,

  348.                 sample_rate,

  349.                 period_size,

  350.                 listen_port,

  351.                 transport_sync,

  352.                 resample_factor,

  353.                 resample_factor_up,

  354.                 bitdepth,

  355. 		use_autoconfig,

  356. 		latency,

  357. 		redundancy,

  358. 		dont_htonl_floats,

  359. 	        always_deadline, 

  360. 		jitter_val	);

  361. 

  362.     netjack_startup( netj );

  363. 

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

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

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

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

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

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

  370. 

  371.     return (jack_driver_t *) driver;

  372. }

  373. 

  374. /* DRIVER "PLUGIN" INTERFACE */

  375. 

  376. jack_driver_desc_t *

  377. driver_get_descriptor ()

  378. {

  379.     jack_driver_desc_t * desc;

  380.     jack_driver_param_desc_t * params;

  381.     unsigned int i;

  382. 

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

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

  385.     desc->nparams = 18;

  386. 

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

  388. 

  389.     i = 0;

  390.     strcpy (params[i].name, "audio-ins");

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

  392.     params[i].type       = JackDriverParamUInt;

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

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

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

  396. 

  397.     i++;

  398.     strcpy (params[i].name, "audio-outs");

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

  400.     params[i].type       = JackDriverParamUInt;

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

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

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

  404. 

  405.     i++;

  406.     strcpy (params[i].name, "midi-ins");

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

  408.     params[i].type       = JackDriverParamUInt;

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

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

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

  412. 

  413.     i++;

  414.     strcpy (params[i].name, "midi-outs");

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

  416.     params[i].type       = JackDriverParamUInt;

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

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

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

  420. 

  421.     i++;

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

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

  424.     params[i].type       = JackDriverParamUInt;

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

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

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

  428. 

  429.     i++;

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

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

  432.     params[i].type       = JackDriverParamUInt;

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

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

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

  436. 

  437.     i++;

  438.     strcpy (params[i].name, "num-periods");

  439.     params[i].character  = 'n';

  440.     params[i].type       = JackDriverParamUInt;

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

  442.     strcpy (params[i].short_desc,

  443.             "Network latency setting in no. of periods");

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

  445. 

  446.     i++;

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

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

  449.     params[i].type       = JackDriverParamUInt;

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

  451.     strcpy (params[i].short_desc,

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

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

  454. 

  455.     i++;

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

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

  458.     params[i].type       = JackDriverParamUInt;

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

  460.     strcpy (params[i].short_desc,

  461.             "Factor for sample rate reduction (deprecated)");

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

  463. 

  464.     i++;

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

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

  467.     params[i].type       = JackDriverParamUInt;

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

  469.     strcpy (params[i].short_desc,

  470.             "Factor for sample rate reduction on the upstream (deprecated)");

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

  472. 

  473.     i++;

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

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

  476.     params[i].type       = JackDriverParamUInt;

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

  478.     strcpy (params[i].short_desc,

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

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

  481. 

  482.     i++;

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

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

  485.     params[i].type       = JackDriverParamUInt;

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

  487.     strcpy (params[i].short_desc,

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

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

  490. 

  491.     i++;

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

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

  494.     params[i].type       = JackDriverParamUInt;

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

  496.     strcpy (params[i].short_desc,

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

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

  499. 

  500.     i++;

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

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

  503.     params[i].type       = JackDriverParamUInt;

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

  505.     strcpy (params[i].short_desc,

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

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

  508.     i++;

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

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

  511.     params[i].type       = JackDriverParamUInt;

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

  513.     strcpy (params[i].short_desc,

  514.             "Send packets N times");

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

  516. 

  517.     i++;

  518.     strcpy (params[i].name, "native-endian");

  519.     params[i].character  = 'e';

  520.     params[i].type       = JackDriverParamUInt;

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

  522.     strcpy (params[i].short_desc,

  523.             "Don't convert samples to network byte order.");

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

  525. 

  526.     i++;

  527.     strcpy (params[i].name, "jitterval");

  528.     params[i].character  = 'J';

  529.     params[i].type       = JackDriverParamInt;

  530.     params[i].value.i   = 0;

  531.     strcpy (params[i].short_desc,

  532.             "attempted jitterbuffer microseconds on master");

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

  534. 

  535.     i++;

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

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

  538.     params[i].type       = JackDriverParamUInt;

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

  540.     strcpy (params[i].short_desc,

  541.             "Always wait until deadline");

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

  543.     desc->params = params;

  544. 

  545.     return desc;

  546. }

  547. 

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

  549. 

  550. jack_driver_t *

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

  552. {

  553.     jack_nframes_t sample_rate = 48000;

  554.     jack_nframes_t resample_factor = 1;

  555.     jack_nframes_t period_size = 1024;

  556.     unsigned int capture_ports = 2;

  557.     unsigned int playback_ports = 2;

  558.     unsigned int capture_ports_midi = 1;

  559.     unsigned int playback_ports_midi = 1;

  560.     unsigned int listen_port = 3000;

  561.     unsigned int resample_factor_up = 0;

  562.     unsigned int bitdepth = 0;

  563.     unsigned int handle_transport_sync = 1;

  564.     unsigned int use_autoconfig = 1;

  565.     unsigned int latency = 5;

  566.     unsigned int redundancy = 1;

  567.     int dont_htonl_floats = 0;

  568.     int always_deadline = 0;

  569.     int jitter_val = 0;

  570.     const JSList * node;

  571.     const jack_driver_param_t * param;

  572. 

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

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

  575. 

  576.         switch (param->character) {

  577. 

  578.             case 'i':

  579.                 capture_ports = param->value.ui;

  580.                 break;

  581. 

  582.             case 'o':

  583.                 playback_ports = param->value.ui;

  584.                 break;

  585. 

  586.             case 'I':

  587.                 capture_ports_midi = param->value.ui;

  588.                 break;

  589. 

  590.             case 'O':

  591.                 playback_ports_midi = param->value.ui;

  592.                 break;

  593. 

  594.             case 'r':

  595.                 sample_rate = param->value.ui;

  596.                 break;

  597. 

  598.             case 'p':

  599.                 period_size = param->value.ui;

  600.                 break;

  601. 

  602.             case 'l':

  603.                 listen_port = param->value.ui;

  604.                 break;

  605. 

  606.             case 'f':

  607. #if HAVE_SAMPLERATE

  608.                 resample_factor = param->value.ui;

  609. #else

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

  611. 		exit(10);

  612. #endif

  613.                 break;

  614. 

  615.             case 'u':

  616. #if HAVE_SAMPLERATE

  617.                 resample_factor_up = param->value.ui;

  618. #else

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

  620. 		exit(10);

  621. #endif

  622.                 break;

  623. 

  624.             case 'b':

  625.                 bitdepth = param->value.ui;

  626.                 break;

  627. 

  628. 	    case 'c':

  629. #if HAVE_CELT

  630. 		bitdepth = 1000;

  631. 		resample_factor = param->value.ui;

  632. #else

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

  634. 		exit(10);

  635. #endif

  636. 		break;

  637. 

  638.             case 't':

  639.                 handle_transport_sync = param->value.ui;

  640.                 break;

  641. 

  642.             case 'a':

  643.                 use_autoconfig = param->value.ui;

  644.                 break;

  645. 

  646.             case 'n':

  647.                 latency = param->value.ui;

  648.                 break;

  649. 

  650.             case 'R':

  651.                 redundancy = param->value.ui;

  652.                 break;

  653. 

  654.             case 'e':

  655.                 dont_htonl_floats = param->value.ui;

  656.                 break;

  657.             case 'J':

  658.                 jitter_val = param->value.ui;

  659.                 break;

  660.             case 'D':

  661.                 always_deadline = param->value.ui;

  662.                 break;

  663.         }

  664.     }

  665. 

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

  667.                            capture_ports_midi, playback_ports_midi,

  668.                            sample_rate, period_size,

  669.                            listen_port, handle_transport_sync,

  670.                            resample_factor, resample_factor_up, bitdepth,

  671. 			   use_autoconfig, latency, redundancy,

  672. 			   dont_htonl_floats, always_deadline, jitter_val);

  673. }

  674. 

  675. void

  676. driver_finish (jack_driver_t *driver)

  677. {

  678.     net_driver_delete ((net_driver_t *) driver);

  679. }