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

709 lines
20KB
Raw Blame History 

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

  2. /*

  3.    NetJack Driver

  4. 

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

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

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

  8.    Copyright (C) 2001 Paul Davis

  9. 

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

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

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

  13.    (at your option) any later version.

  14. 

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

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

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

  18.    GNU General Public License for more details.

  19. 

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

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

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

  23. 

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

  25.  */

  26. 

  27. #include <math.h>

  28. #include <stdio.h>

  29. #include <memory.h>

  30. #include <unistd.h>

  31. #include <stdlib.h>

  32. #include <errno.h>

  33. #include <stdarg.h>

  34. #include <sys/mman.h>

  35. 

  36. #include <jack/types.h>

  37. #include "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, driver->engine->get_microseconds );

  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 = driver->engine->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. 

  100. 	if (wait_status < 0) {

  101. 		return -1;

  102. 	} else {

  103. 		return 0;

  104. 	}

  105. }

  106. 

  107. static int

  108. net_driver_null_cycle (net_driver_t* driver, jack_nframes_t nframes)

  109. {

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

  111. 	//       do i wait here ?

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

  113. 

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

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

  116. 

  117. 	netjack_send_silence ( netj, sync_state );

  118. 

  119. 	return 0;

  120. }

  121. 

  122. static int

  123. net_driver_bufsize (net_driver_t* driver, jack_nframes_t nframes)

  124. {

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

  126. 

  127. 	if (nframes != netj->period_size) {

  128. 		return EINVAL;

  129. 	}

  130. 

  131. 	return 0;

  132. }

  133. 

  134. static int

  135. net_driver_read (net_driver_t* driver, jack_nframes_t nframes)

  136. {

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

  138. 

  139. 	jack_position_t local_trans_pos;

  140. 	jack_transport_state_t local_trans_state;

  141. 

  142. 	unsigned int *packet_buf, *packet_bufX;

  143. 

  144. 	if ( !netj->packet_data_valid ) {

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

  146. 		return 0;

  147. 	}

  148. 	packet_buf = netj->rx_buf;

  149. 

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

  151. 

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

  153. 

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

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

  156. 

  157. 	// Special handling for latency=0

  158. 	if ( netj->latency == 0 ) {

  159. 		netj->resync_threshold = 0;

  160. 	} else {

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

  162. 	}

  163. 

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

  165. 	if (netj->handle_transport_sync) {

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

  167. 

  168. 		// read local transport info....

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

  170. 

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

  172. 		switch (pkthdr->transport_state) {

  173. 		case JackTransportStarting:

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

  175. 			if (local_trans_state == JackTransportStopped) {

  176. 				jack_transport_start (netj->client);

  177. 				last_transport_state = JackTransportStopped;

  178. 				sync_state = FALSE;

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

  180. 			}

  181. 

  182. 			if (local_trans_pos.frame != compensated_tranport_pos) {

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

  184. 				last_transport_state = JackTransportRolling;

  185. 				sync_state = FALSE;

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

  187. 			}

  188. 			break;

  189. 		case JackTransportStopped:

  190. 			sync_state = TRUE;

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

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

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

  194. 			}

  195. 			if (local_trans_state != JackTransportStopped) {

  196. 				jack_transport_stop (netj->client);

  197. 			}

  198. 			break;

  199. 		case JackTransportRolling:

  200. 			sync_state = TRUE;

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

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

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

  204. //		                }

  205. 			if (local_trans_state != JackTransportRolling) {

  206. 				jack_transport_start (netj->client);

  207. 			}

  208. 			break;

  209. 

  210. 		case JackTransportLooping:

  211. 			break;

  212. 		}

  213. 	}

  214. 

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

  216. 	packet_cache_release_packet (netj->packcache, netj->expected_framecnt );

  217. 

  218. 	return 0;

  219. }

  220. 

  221. static int

  222. net_driver_write (net_driver_t* driver, jack_nframes_t nframes)

  223. {

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

  225. 

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

  227. 

  228. 	uint32_t *packet_buf, *packet_bufX;

  229. 

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

  231. 	jacknet_packet_header *pkthdr;

  232. 

  233. 	packet_buf = alloca (packet_size);

  234. 	pkthdr = (jacknet_packet_header*)packet_buf;

  235. 

  236. 	if ( netj->running_free ) {

  237. 		return 0;

  238. 	}

  239. 

  240. 	// offset packet_bufX by the packetheader.

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

  242. 

  243. 	// clear unused header fields

  244. 	pkthdr->capture_channels_audio = 0;

  245. 	pkthdr->playback_channels_audio = 0;

  246. 	pkthdr->capture_channels_midi = 0;

  247. 	pkthdr->playback_channels_midi = 0;

  248. 	pkthdr->period_size = 0;

  249. 	pkthdr->sample_rate = 0;

  250. 	pkthdr->transport_frame = 0;

  251. 	pkthdr->transport_state = 0;

  252. 	pkthdr->framecnt = 0;

  253. 	pkthdr->reply_port = 0;

  254. 	pkthdr->mtu = 0;

  255. 

  256. 	// set used header fields

  257. 	pkthdr->sync_state = sync_state;

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

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

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

  261. 

  262. 

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

  264. 

  265. 	packet_header_hton (pkthdr);

  266. 	if (netj->srcaddress_valid) {

  267. 		int r;

  268. 

  269. #ifndef MSG_CONFIRM

  270. 		static const int flag = 0;

  271. #else

  272. 		static const int flag = MSG_CONFIRM;

  273. #endif

  274. 

  275. 		if (netj->reply_port) {

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

  277. 		}

  278. 

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

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

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

  282. 	}

  283. 

  284. 	return 0;

  285. }

  286. 

  287. 

  288. static int

  289. net_driver_attach (net_driver_t *driver)

  290. {

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

  292. 

  293. 	if (driver->engine->set_buffer_size (driver->engine, netj->period_size)) {

  294. 		jack_error ("netjack: cannot set engine buffer size to %d (check MIDI)", netj->period_size);

  295. 		return -1;

  296. 	}

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

  298. 

  299. 	netjack_attach ( netj );

  300. 	return 0;

  301. }

  302. 

  303. static int

  304. net_driver_detach (net_driver_t *driver)

  305. {

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

  307. 

  308. 	if (driver->engine == 0) {

  309. 		return 0;

  310. 	}

  311. 

  312. 	netjack_detach ( netj );

  313. 	return 0;

  314. }

  315. 

  316. static void

  317. net_driver_delete (net_driver_t *driver)

  318. {

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

  320. 

  321. 	netjack_release ( netj );

  322. 	jack_driver_nt_finish ((jack_driver_nt_t*)driver);

  323. 	free (driver);

  324. }

  325. 

  326. static jack_driver_t *

  327. net_driver_new (jack_client_t * client,

  328. 		char *name,

  329. 		unsigned int capture_ports,

  330. 		unsigned int playback_ports,

  331. 		unsigned int capture_ports_midi,

  332. 		unsigned int playback_ports_midi,

  333. 		jack_nframes_t sample_rate,

  334. 		jack_nframes_t period_size,

  335. 		unsigned int listen_port,

  336. 		unsigned int transport_sync,

  337. 		unsigned int resample_factor,

  338. 		unsigned int resample_factor_up,

  339. 		unsigned int bitdepth,

  340. 		unsigned int use_autoconfig,

  341. 		unsigned int latency,

  342. 		unsigned int redundancy,

  343. 		int dont_htonl_floats,

  344. 		int always_deadline,

  345. 		int jitter_val)

  346. {

  347. 	net_driver_t * driver;

  348. 

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

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

  351. 		   capture_ports, playback_ports, transport_sync);

  352. 

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

  354. 

  355. 	jack_driver_nt_init ((jack_driver_nt_t*)driver);

  356. 

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

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

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

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

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

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

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

  364. 

  365. 	driver->last_wait_ust = 0;

  366. 	driver->engine = NULL;

  367. 

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

  369. 

  370. 	netjack_init ( netj,

  371. 		       client,

  372. 		       name,

  373. 		       capture_ports,

  374. 		       playback_ports,

  375. 		       capture_ports_midi,

  376. 		       playback_ports_midi,

  377. 		       sample_rate,

  378. 		       period_size,

  379. 		       listen_port,

  380. 		       transport_sync,

  381. 		       resample_factor,

  382. 		       resample_factor_up,

  383. 		       bitdepth,

  384. 		       use_autoconfig,

  385. 		       latency,

  386. 		       redundancy,

  387. 		       dont_htonl_floats,

  388. 		       always_deadline,

  389. 		       jitter_val      );

  390. 

  391. 	netjack_startup ( netj );

  392. 

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

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

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

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

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

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

  399. 

  400. 	return (jack_driver_t*)driver;

  401. }

  402. 

  403. /* DRIVER "PLUGIN" INTERFACE */

  404. 

  405. jack_driver_desc_t *

  406. driver_get_descriptor ()

  407. {

  408. 	jack_driver_desc_t * desc;

  409. 	jack_driver_param_desc_t * params;

  410. 	unsigned int i;

  411. 

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

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

  414. 	desc->nparams = 18;

  415. 

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

  417. 

  418. 	i = 0;

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

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

  421. 	params[i].type       = JackDriverParamUInt;

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

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

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

  425. 

  426. 	i++;

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

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

  429. 	params[i].type       = JackDriverParamUInt;

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

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

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

  433. 

  434. 	i++;

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

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

  437. 	params[i].type       = JackDriverParamUInt;

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

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

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

  441. 

  442. 	i++;

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

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

  445. 	params[i].type       = JackDriverParamUInt;

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

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

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

  449. 

  450. 	i++;

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

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

  453. 	params[i].type       = JackDriverParamUInt;

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

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

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

  457. 

  458. 	i++;

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

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

  461. 	params[i].type       = JackDriverParamUInt;

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

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

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

  465. 

  466. 	i++;

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

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

  469. 	params[i].type       = JackDriverParamUInt;

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

  471. 	strcpy (params[i].short_desc,

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

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

  474. 

  475. 	i++;

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

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

  478. 	params[i].type       = JackDriverParamUInt;

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

  480. 	strcpy (params[i].short_desc,

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

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

  483. 

  484. 	i++;

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

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

  487. 	params[i].type       = JackDriverParamUInt;

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

  489. 	strcpy (params[i].short_desc,

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

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

  492. 

  493. 	i++;

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

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

  496. 	params[i].type       = JackDriverParamUInt;

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

  498. 	strcpy (params[i].short_desc,

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

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

  501. 

  502. 	i++;

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

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

  505. 	params[i].type       = JackDriverParamUInt;

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

  507. 	strcpy (params[i].short_desc,

  508. 		"sets celt encoding and kbits value one channel is encoded at");

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

  510. 

  511. 	i++;

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

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

  514. 	params[i].type       = JackDriverParamUInt;

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

  516. 	strcpy (params[i].short_desc,

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

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

  519. 

  520. 	i++;

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

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

  523. 	params[i].type       = JackDriverParamUInt;

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

  525. 	strcpy (params[i].short_desc,

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

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

  528. 

  529. 	i++;

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

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

  532. 	params[i].type       = JackDriverParamUInt;

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

  534. 	strcpy (params[i].short_desc,

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

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

  537. 	i++;

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

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

  540. 	params[i].type       = JackDriverParamUInt;

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

  542. 	strcpy (params[i].short_desc,

  543. 		"Send packets N times");

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

  545. 

  546. 	i++;

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

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

  549. 	params[i].type       = JackDriverParamUInt;

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

  551. 	strcpy (params[i].short_desc,

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

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

  554. 

  555. 	i++;

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

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

  558. 	params[i].type       = JackDriverParamInt;

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

  560. 	strcpy (params[i].short_desc,

  561. 		"attempted jitterbuffer microseconds on master");

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

  563. 

  564. 	i++;

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

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

  567. 	params[i].type       = JackDriverParamUInt;

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

  569. 	strcpy (params[i].short_desc,

  570. 		"Always wait until deadline");

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

  572. 	desc->params = params;

  573. 

  574. 	return desc;

  575. }

  576. 

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

  578. 

  579. jack_driver_t *

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

  581. {

  582. 	jack_nframes_t sample_rate = 48000;

  583. 	jack_nframes_t resample_factor = 1;

  584. 	jack_nframes_t period_size = 1024;

  585. 	unsigned int capture_ports = 2;

  586. 	unsigned int playback_ports = 2;

  587. 	unsigned int capture_ports_midi = 1;

  588. 	unsigned int playback_ports_midi = 1;

  589. 	unsigned int listen_port = 3000;

  590. 	unsigned int resample_factor_up = 0;

  591. 	unsigned int bitdepth = 0;

  592. 	unsigned int handle_transport_sync = 1;

  593. 	unsigned int use_autoconfig = 1;

  594. 	unsigned int latency = 5;

  595. 	unsigned int redundancy = 1;

  596. 	int dont_htonl_floats = 0;

  597. 	int always_deadline = 0;

  598. 	int jitter_val = 0;

  599. 	const JSList * node;

  600. 	const jack_driver_param_t * param;

  601. 

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

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

  604. 

  605. 		switch (param->character) {

  606. 

  607. 		case 'i':

  608. 			capture_ports = param->value.ui;

  609. 			break;

  610. 

  611. 		case 'o':

  612. 			playback_ports = param->value.ui;

  613. 			break;

  614. 

  615. 		case 'I':

  616. 			capture_ports_midi = param->value.ui;

  617. 			break;

  618. 

  619. 		case 'O':

  620. 			playback_ports_midi = param->value.ui;

  621. 			break;

  622. 

  623. 		case 'r':

  624. 			sample_rate = param->value.ui;

  625. 			break;

  626. 

  627. 		case 'p':

  628. 			period_size = param->value.ui;

  629. 			break;

  630. 

  631. 		case 'l':

  632. 			listen_port = param->value.ui;

  633. 			break;

  634. 

  635. 		case 'f':

  636. #if HAVE_SAMPLERATE

  637. 			resample_factor = param->value.ui;

  638. #else

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

  640. 			exit (10);

  641. #endif

  642. 			break;

  643. 

  644. 		case 'u':

  645. #if HAVE_SAMPLERATE

  646. 			resample_factor_up = param->value.ui;

  647. #else

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

  649. 			exit (10);

  650. #endif

  651. 			break;

  652. 

  653. 		case 'b':

  654. 			bitdepth = param->value.ui;

  655. 			break;

  656. 

  657. 		case 'c':

  658. #if HAVE_CELT

  659. 			bitdepth = 1000;

  660. 			resample_factor = param->value.ui;

  661. #else

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

  663. 			exit (10);

  664. #endif

  665. 			break;

  666. 

  667. 		case 't':

  668. 			handle_transport_sync = param->value.ui;

  669. 			break;

  670. 

  671. 		case 'a':

  672. 			use_autoconfig = param->value.ui;

  673. 			break;

  674. 

  675. 		case 'n':

  676. 			latency = param->value.ui;

  677. 			break;

  678. 

  679. 		case 'R':

  680. 			redundancy = param->value.ui;

  681. 			break;

  682. 

  683. 		case 'e':

  684. 			dont_htonl_floats = param->value.ui;

  685. 			break;

  686. 		case 'J':

  687. 			jitter_val = param->value.i;

  688. 			break;

  689. 		case 'D':

  690. 			always_deadline = param->value.ui;

  691. 			break;

  692. 		}

  693. 	}

  694. 

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

  696. 			       capture_ports_midi, playback_ports_midi,

  697. 			       sample_rate, period_size,

  698. 			       listen_port, handle_transport_sync,

  699. 			       resample_factor, resample_factor_up, bitdepth,

  700. 			       use_autoconfig, latency, redundancy,

  701. 			       dont_htonl_floats, always_deadline, jitter_val);

  702. }

  703. 

  704. void

  705. driver_finish (jack_driver_t *driver)

  706. {

  707. 	net_driver_delete ((net_driver_t*)driver);

  708. }