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

1169 lines
40KB
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. #include <sys/socket.h>

  42. #include <netinet/in.h>

  43. 

  44. #include "config.h"

  45. 

  46. #if HAVE_SAMPLERATE

  47. #include <samplerate.h>

  48. #endif

  49. 

  50. #if HAVE_CELT

  51. #include <celt/celt.h>

  52. #endif

  53. 

  54. #include "net_driver.h"

  55. #include "netjack_packet.h"

  56. 

  57. #undef DEBUG_WAKEUP

  58. 

  59. #define MIN(x,y) ((x)<(y) ? (x) : (y))

  60. 

  61. static int sync_state = TRUE;

  62. static jack_transport_state_t last_transport_state;

  63. 

  64. static int

  65. net_driver_sync_cb(jack_transport_state_t state, jack_position_t *pos, net_driver_t *driver)

  66. {

  67.     int retval = sync_state;

  68. 

  69.     if (state == JackTransportStarting && last_transport_state != JackTransportStarting) {

  70.         retval = 0;

  71.     }

  72. //    if (state == JackTransportStarting) 

  73. //		jack_info("Starting sync_state = %d", sync_state);

  74.     last_transport_state = state;

  75.     return retval;

  76. }

  77. 

  78. static jack_nframes_t

  79. net_driver_wait (net_driver_t *driver, int extra_fd, int *status, float *delayed_usecs)

  80. {

  81.     // ok... we wait for a packet on the socket

  82.     // TODO:

  83.     // we should be able to run freely if the sync source is not transmitting

  84.     // especially we should be able to compensate for packet loss somehow.

  85.     // but lets try this out first.

  86.     //

  87.     // on packet loss we should either detect an xrun or just continue running when we

  88.     // think, that the sync source is not running anymore.

  89. 

  90.     //socklen_t address_size = sizeof (struct sockaddr_in);

  91.     //int len;

  92.     int we_have_the_expected_frame = 0;

  93.     jack_nframes_t next_frame_avail;

  94.     jack_time_t packet_recv_time_stamp;

  95.     jacknet_packet_header *pkthdr = (jacknet_packet_header *) driver->rx_buf;

  96.     

  97.     if( !driver->next_deadline_valid ) {

  98. 	    if( driver->latency == 0 )

  99. 		// for full sync mode... always wait for packet.

  100. 		driver->next_deadline = jack_get_microseconds() + 500*driver->period_usecs;

  101. 	    else if( driver->latency == 1 )

  102. 		// for normal 1 period latency mode, only 1 period for dealine.

  103. 		driver->next_deadline = jack_get_microseconds() + driver->period_usecs;

  104. 	    else

  105. 		// looks like waiting 1 period always is correct.

  106. 		// not 100% sure yet. with the improved resync, it might be better,

  107. 		// to have more than one period headroom for high latency.

  108. 		//driver->next_deadline = jack_get_microseconds() + 5*driver->latency*driver->period_usecs/4;

  109. 		driver->next_deadline = jack_get_microseconds() + 1*driver->period_usecs;

  110. 

  111. 	    driver->next_deadline_valid = 1;

  112.     } else {

  113. 	    driver->next_deadline += driver->period_usecs;

  114.     }

  115. 

  116.     // Increment expected frame here.

  117.     driver->expected_framecnt += 1;

  118. 

  119.     // Now check if required packet is already in the cache.

  120.     // then poll (have deadline calculated)

  121.     // then drain socket, rinse and repeat.

  122.     while(1) {

  123. 	if( packet_cache_get_next_available_framecnt( global_packcache, driver->expected_framecnt, &next_frame_avail) ) {

  124. 	    if( next_frame_avail == driver->expected_framecnt ) {

  125. 		we_have_the_expected_frame = 1;

  126. 		if( ! driver->always_wait_dedline )

  127. 			break;

  128. 	    }

  129. 	}

  130. 	if( ! netjack_poll_deadline( driver->sockfd, driver->next_deadline ) )

  131. 	    break;

  132. 

  133. 	packet_cache_drain_socket( global_packcache, driver->sockfd );

  134.     }

  135. 

  136.     // check if we know who to send our packets too.

  137.     // TODO: there is still something wrong when trying

  138.     // to send back to another port on localhost.

  139.     // need to use -r on netsource for that.

  140.     if (!driver->srcaddress_valid)

  141. 	if( global_packcache->master_address_valid ) {

  142. 	    memcpy (&(driver->syncsource_address), &(global_packcache->master_address), sizeof( struct sockaddr_in ) );

  143. 	    driver->srcaddress_valid = 1;

  144. 	}

  145. 

  146.     // XXX: switching mode unconditionally is stupid.

  147.     //      if we were running free perhaps we like to behave differently

  148.     //      ie. fastforward one packet etc.

  149.     //      well... this is the first packet we see. hmm.... dunno ;S

  150.     //      it works... so...

  151.     driver->running_free = 0;

  152. 

  153.     if( we_have_the_expected_frame ) {

  154. 	driver->time_to_deadline = driver->next_deadline - jack_get_microseconds() - driver->period_usecs;

  155. 	packet_cache_retreive_packet( global_packcache, driver->expected_framecnt, (char *) driver->rx_buf, driver->rx_bufsize , &packet_recv_time_stamp);

  156. 	//int recv_time_offset = (int) (jack_get_microseconds() - packet_recv_time_stamp);

  157. 	packet_header_ntoh(pkthdr);

  158. 	driver->deadline_goodness = (int)pkthdr->sync_state;

  159. 	driver->packet_data_valid = 1;

  160. 	

  161. 	// TODO: Queue state could be taken into account.

  162. 	//       But needs more processing, cause, when we are running as

  163. 	//       fast as we can, recv_time_offset can be zero, which is

  164. 	//       good.

  165. 	//       need to add (now-deadline) and check that.

  166. 	/*

  167. 	if( recv_time_offset < driver->period_usecs )

  168. 	    //driver->next_deadline -= driver->period_usecs*driver->latency/100;

  169. 	    driver->next_deadline += driver->period_usecs/1000;

  170. 	    */

  171. 

  172. 	if( driver->deadline_goodness < 10*(int)driver->period_usecs/100*driver->latency ) {

  173. 	    driver->next_deadline -= driver->period_usecs/1000;

  174. 	    //printf( "goodness: %d, Adjust deadline: --- %d\n", driver->deadline_goodness, (int) driver->period_usecs*driver->latency/100 );

  175. 	}

  176. 	if( driver->deadline_goodness > 10*(int)driver->period_usecs/100*driver->latency ) {

  177. 	    driver->next_deadline += driver->period_usecs/1000;

  178. 	    //printf( "goodness: %d, Adjust deadline: +++ %d\n", driver->deadline_goodness, (int) driver->period_usecs*driver->latency/100 );

  179. 	}

  180.     } else {

  181. 	driver->time_to_deadline = 0;

  182. 	// bah... the packet is not there.

  183. 	// either 

  184. 	// - it got lost.

  185. 	// - its late

  186. 	// - sync source is not sending anymore.

  187. 	

  188. 	// lets check if we have the next packets, we will just run a cycle without data.

  189. 	// in that case.

  190. 	

  191. 	if( packet_cache_get_next_available_framecnt( global_packcache, driver->expected_framecnt, &next_frame_avail) ) 

  192. 	{

  193. 	    jack_nframes_t offset = next_frame_avail - driver->expected_framecnt;

  194. 

  195. 	    //if( offset < driver->resync_threshold )

  196. 	    if( offset < 10 ) {

  197. 		// ok. dont do nothing. we will run without data. 

  198. 		// this seems to be one or 2 lost packets.

  199. 		//

  200. 		// this can also be reordered packet jitter.

  201. 		// (maybe this is not happening in real live)

  202. 		//  but it happens in netem.

  203. 

  204. 		driver->packet_data_valid = 0;

  205. 

  206. 		// I also found this happening, when the packet queue, is too full.

  207. 		// but wtf ? use a smaller latency. this link can handle that ;S

  208. 		if( packet_cache_get_fill( global_packcache, driver->expected_framecnt ) > 80.0 )

  209. 		    driver->next_deadline -= driver->period_usecs/2;

  210. 

  211. 		

  212. 	    } else {

  213. 		// the diff is too high. but we have a packet in the future.

  214. 		// lets resync.

  215. 		driver->expected_framecnt = next_frame_avail;

  216. 		packet_cache_retreive_packet( global_packcache, driver->expected_framecnt, (char *) driver->rx_buf, driver->rx_bufsize, NULL );

  217. 		packet_header_ntoh(pkthdr);

  218. 		//driver->deadline_goodness = 0;

  219. 		driver->deadline_goodness = (int)pkthdr->sync_state - (int)driver->period_usecs * offset;

  220. 		driver->next_deadline_valid = 0;

  221. 		driver->packet_data_valid = 1;

  222. 	    }

  223. 	    

  224. 	} else {

  225. 	    // no packets in buffer.

  226. 	    driver->packet_data_valid = 0;

  227. 	    

  228. 	    //printf( "frame %d No Packet in queue. num_lost_packets = %d \n", driver->expected_framecnt, driver->num_lost_packets ); 

  229. 	    if( driver->num_lost_packets < 5 ) {

  230. 		// ok. No Packet in queue. The packet was either lost,

  231. 		// or we are running too fast.

  232. 		//

  233. 		// Adjusting the deadline unconditionally resulted in

  234. 		// too many xruns on master.

  235. 		// But we need to adjust for the case we are running too fast.

  236. 		// So lets check if the last packet is there now.

  237. 		//

  238. 		// It would not be in the queue anymore, if it had been

  239. 		// retrieved. This might break for redundancy, but

  240. 		// i will make the packet cache drop redundant packets,

  241. 		// that have already been retreived.

  242. 		//

  243. 		if( packet_cache_get_highest_available_framecnt( global_packcache, &next_frame_avail) ) {

  244. 		    if( next_frame_avail == (driver->expected_framecnt - 1) ) {

  245. 			// Ok. the last packet is there now.

  246. 			// and it had not been retrieved.

  247. 			// 

  248. 			// TODO: We are still dropping 2 packets.

  249. 			//       perhaps we can adjust the deadline

  250. 			//       when (num_packets lost == 0)

  251. 			

  252. 			// This might still be too much.

  253. 			driver->next_deadline += driver->period_usecs/8;

  254. 		    }

  255. 		}

  256. 	    } else if( (driver->num_lost_packets <= 10) ) { 

  257. 		// lets try adjusting the deadline harder, for some packets, we might have just ran 2 fast.

  258. 		//driver->next_deadline += driver->period_usecs*driver->latency/8;

  259. 	    } else {

  260. 		

  261. 		// But now we can check for any new frame available.

  262. 		//

  263. 		if( packet_cache_get_highest_available_framecnt( global_packcache, &next_frame_avail) ) {

  264. 		    driver->expected_framecnt = next_frame_avail;

  265. 		    packet_cache_retreive_packet( global_packcache, driver->expected_framecnt, (char *) driver->rx_buf, driver->rx_bufsize, NULL );

  266. 		    packet_header_ntoh(pkthdr);

  267. 		    driver->deadline_goodness = pkthdr->sync_state;

  268. 		    driver->next_deadline_valid = 0;

  269. 		    driver->packet_data_valid = 1;

  270. 		    driver->running_free = 0;

  271. 		    printf( "resync after freerun... %d\n", driver->expected_framecnt );

  272. 		} else {

  273. 		    // give up. lets run freely.

  274. 		    // XXX: hmm... 

  275. 

  276. 		    driver->running_free = 1;

  277. 

  278. 		    // when we really dont see packets.

  279. 		    // reset source address. and open possibility for new master.

  280. 		    // maybe dsl reconnect. Also restart of netsource without fix

  281. 		    // reply address changes port.

  282. 		    if (driver->num_lost_packets > 200 ) {

  283. 			driver->srcaddress_valid = 0;

  284. 			packet_cache_reset_master_address( global_packcache );

  285. 		    }

  286. 		}

  287. 	    }

  288. 	}

  289.     }

  290. 

  291.     if( !driver->packet_data_valid )

  292. 	driver->num_lost_packets += 1;

  293.     else {

  294. 	driver->num_lost_packets = 0;

  295. 	//packet_header_ntoh (pkthdr);

  296.     }

  297. 

  298. 

  299.     

  300.     driver->last_wait_ust = jack_get_microseconds ();

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

  302. 

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

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

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

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

  307.     *status = 0;

  308.     return driver->period_size;

  309. }

  310. 

  311. static inline int

  312. net_driver_run_cycle (net_driver_t *driver)

  313. {

  314.     jack_engine_t *engine = driver->engine;

  315.     int wait_status = -1;

  316.     float delayed_usecs;

  317. 

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

  319.                              &delayed_usecs);

  320. 

  321.     // XXX: xrun code removed.

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

  323.     //      things are different on the net.

  324. 

  325.     if (wait_status == 0)

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

  327. 

  328.     if (wait_status < 0)

  329.         return -1;

  330.     else

  331.         return 0;

  332. }

  333. 

  334. static int

  335. net_driver_null_cycle (net_driver_t* driver, jack_nframes_t nframes)

  336. {

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

  338.     //       do i wait here ?

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

  340. 

  341.     //int rx_size = get_sample_size(driver->bitdepth) * driver->capture_channels * driver->net_period_down + sizeof(jacknet_packet_header);

  342.     int tx_size = get_sample_size(driver->bitdepth) * driver->playback_channels * driver->net_period_up + sizeof(jacknet_packet_header);

  343.     unsigned int *packet_buf, *packet_bufX;

  344. 

  345.     packet_buf = alloca( tx_size);

  346.     jacknet_packet_header *tx_pkthdr = (jacknet_packet_header *)packet_buf;

  347.     jacknet_packet_header *rx_pkthdr = (jacknet_packet_header *)driver->rx_buf;

  348. 

  349.     //framecnt = rx_pkthdr->framecnt;

  350. 

  351.     driver->reply_port = rx_pkthdr->reply_port;

  352. 

  353.     // offset packet_bufX by the packetheader.

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

  355. 

  356.     tx_pkthdr->sync_state = (driver->engine->control->sync_remain <= 1);

  357. 

  358.     tx_pkthdr->framecnt = driver->expected_framecnt;

  359. 

  360.     // memset 0 the payload.

  361.     int payload_size = get_sample_size(driver->bitdepth) * driver->playback_channels * driver->net_period_up;

  362.     memset(packet_bufX, 0, payload_size);

  363. 

  364.     packet_header_hton(tx_pkthdr);

  365.     if (driver->srcaddress_valid)

  366.     {

  367. 	int r;

  368. 	if (driver->reply_port)

  369. 	    driver->syncsource_address.sin_port = htons(driver->reply_port);

  370. 

  371. 	for( r=0; r<driver->redundancy; r++ )

  372. 	    netjack_sendto(driver->outsockfd, (char *)packet_buf, tx_size,

  373. 		    0, (struct sockaddr*)&(driver->syncsource_address), sizeof(struct sockaddr_in), driver->mtu);

  374.     }

  375. 

  376.     return 0;

  377. }

  378. 

  379. static int

  380. net_driver_bufsize (net_driver_t* driver, jack_nframes_t nframes)

  381. {

  382.     if (nframes != driver->period_size)

  383.         return EINVAL;

  384. 

  385.     return 0;

  386. }

  387. 

  388. static int

  389. net_driver_read (net_driver_t* driver, jack_nframes_t nframes)

  390. {

  391.     jack_position_t local_trans_pos;

  392.     jack_transport_state_t local_trans_state;

  393. 

  394.     unsigned int *packet_buf, *packet_bufX;

  395. 

  396.     if( ! driver->packet_data_valid ) {

  397. 	render_payload_to_jack_ports (driver->bitdepth, NULL, driver->net_period_down, driver->capture_ports, driver->capture_srcs, nframes, driver->dont_htonl_floats );

  398. 	return 0;

  399.     }

  400.     packet_buf = driver->rx_buf;

  401. 

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

  403. 

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

  405. 

  406.     driver->reply_port = pkthdr->reply_port;

  407.     driver->latency = pkthdr->latency;

  408. 

  409.     // Special handling for latency=0

  410.     if( driver->latency == 0 )

  411. 	driver->resync_threshold = 0;

  412.     else

  413. 	driver->resync_threshold = MIN( 15, pkthdr->latency-1 );

  414. 

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

  416.     if (driver->handle_transport_sync) {

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

  418. 

  419.         // read local transport info....

  420.         local_trans_state = jack_transport_query(driver->client, &local_trans_pos);

  421. 

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

  423.         switch (pkthdr->transport_state) {

  424.             case JackTransportStarting:

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

  426.                 if (local_trans_state == JackTransportStopped) {

  427.                     jack_transport_start(driver->client);

  428.                     last_transport_state = JackTransportStopped;

  429.                     sync_state = FALSE;

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

  431.                 }

  432. 

  433.                 if (local_trans_pos.frame != compensated_tranport_pos)

  434. 		{

  435.                     jack_transport_locate(driver->client, compensated_tranport_pos);

  436.                     last_transport_state = JackTransportRolling;

  437.                     sync_state = FALSE;

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

  439.                 }

  440.                 break;

  441.             case JackTransportStopped:

  442.                 sync_state = TRUE;

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

  444.                     jack_transport_locate(driver->client, (pkthdr->transport_frame));

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

  446.                 }

  447.                 if (local_trans_state != JackTransportStopped)

  448.                     jack_transport_stop(driver->client);

  449.                 break;

  450.             case JackTransportRolling:

  451.                 sync_state = TRUE;

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

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

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

  455. //		    		}

  456.                 if (local_trans_state != JackTransportRolling)

  457.                     jack_transport_start (driver->client);

  458.                 break;

  459. 

  460.             case JackTransportLooping:

  461.                 break;

  462.         }

  463.     }

  464. 

  465.     render_payload_to_jack_ports (driver->bitdepth, packet_bufX, driver->net_period_down, driver->capture_ports, driver->capture_srcs, nframes, driver->dont_htonl_floats );

  466. 

  467.     return 0;

  468. }

  469. 

  470. static int

  471. net_driver_write (net_driver_t* driver, jack_nframes_t nframes)

  472. {

  473.     uint32_t *packet_buf, *packet_bufX;

  474. 

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

  476.     jacknet_packet_header *pkthdr; 

  477. 

  478.     packet_buf = alloca(packet_size);

  479.     pkthdr = (jacknet_packet_header *)packet_buf;

  480. 

  481.     if( driver->running_free ) {

  482. 	return 0;

  483.     }

  484. 

  485.     // offset packet_bufX by the packetheader.

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

  487. 

  488.     pkthdr->sync_state = (driver->engine->control->sync_remain <= 1);

  489.     pkthdr->latency = driver->time_to_deadline;

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

  491.     pkthdr->framecnt = driver->expected_framecnt;

  492. 

  493. 

  494.     render_jack_ports_to_payload(driver->bitdepth, driver->playback_ports, driver->playback_srcs, nframes, packet_bufX, driver->net_period_up, driver->dont_htonl_floats );

  495. 

  496.     packet_header_hton(pkthdr);

  497.     if (driver->srcaddress_valid)

  498.     {

  499. 	int r;

  500. 

  501. #ifndef MSG_CONFIRM

  502. 	static const int flag = 0;

  503. #else

  504. 	static const int flag = MSG_CONFIRM;

  505. #endif

  506. 

  507.         if (driver->reply_port)

  508.             driver->syncsource_address.sin_port = htons(driver->reply_port);

  509. 

  510. 	for( r=0; r<driver->redundancy; r++ )

  511. 	    netjack_sendto(driver->outsockfd, (char *)packet_buf, packet_size,

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

  513.     }

  514. 

  515.     return 0;

  516. }

  517. 

  518. 

  519. static int

  520. net_driver_attach (net_driver_t *driver)

  521. {

  522.     //puts ("net_driver_attach");

  523.     jack_port_t * port;

  524.     char buf[32];

  525.     unsigned int chn;

  526.     int port_flags;

  527. 

  528.     driver->engine->set_buffer_size (driver->engine, driver->period_size);

  529.     driver->engine->set_sample_rate (driver->engine, driver->sample_rate);

  530. 

  531.     if (driver->handle_transport_sync)

  532.         jack_set_sync_callback(driver->client, (JackSyncCallback) net_driver_sync_cb, driver);

  533. 

  534.     port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  535. 

  536.     for (chn = 0; chn < driver->capture_channels_audio; chn++) {

  537.         snprintf (buf, sizeof(buf) - 1, "capture_%u", chn + 1);

  538. 

  539.         port = jack_port_register (driver->client, buf,

  540.                                    JACK_DEFAULT_AUDIO_TYPE,

  541.                                    port_flags, 0);

  542.         if (!port) {

  543.             jack_error ("NET: cannot register port for %s", buf);

  544.             break;

  545.         }

  546. 

  547.         driver->capture_ports =

  548.             jack_slist_append (driver->capture_ports, port);

  549. 

  550. 	if( driver->bitdepth == 1000 ) {

  551. #if HAVE_CELT

  552. 	    celt_int32_t lookahead;

  553. 	    // XXX: memory leak

  554. 	    CELTMode *celt_mode = celt_mode_create( driver->sample_rate, 1, driver->period_size, NULL );

  555. 	    celt_mode_info( celt_mode, CELT_GET_LOOKAHEAD, &lookahead );

  556. 	    driver->codec_latency = 2*lookahead;

  557. 

  558. 	    driver->capture_srcs = jack_slist_append(driver->capture_srcs, celt_decoder_create( celt_mode ) );

  559. #endif

  560. 	} else {

  561. #if HAVE_SAMPLERATE 

  562. 	    driver->capture_srcs = jack_slist_append(driver->capture_srcs, src_new(SRC_LINEAR, 1, NULL));

  563. #endif

  564. 	}

  565.     }

  566.     for (chn = driver->capture_channels_audio; chn < driver->capture_channels; chn++) {

  567.         snprintf (buf, sizeof(buf) - 1, "capture_%u", chn + 1);

  568. 

  569.         port = jack_port_register (driver->client, buf,

  570.                                    JACK_DEFAULT_MIDI_TYPE,

  571.                                    port_flags, 0);

  572.         if (!port) {

  573.             jack_error ("NET: cannot register port for %s", buf);

  574.             break;

  575.         }

  576. 

  577.         driver->capture_ports =

  578.             jack_slist_append (driver->capture_ports, port);

  579.     }

  580. 

  581.     port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  582. 

  583.     for (chn = 0; chn < driver->playback_channels_audio; chn++) {

  584.         snprintf (buf, sizeof(buf) - 1, "playback_%u", chn + 1);

  585. 

  586.         port = jack_port_register (driver->client, buf,

  587.                                    JACK_DEFAULT_AUDIO_TYPE,

  588.                                    port_flags, 0);

  589. 

  590.         if (!port) {

  591.             jack_error ("NET: cannot register port for %s", buf);

  592.             break;

  593.         }

  594. 

  595.         driver->playback_ports =

  596.             jack_slist_append (driver->playback_ports, port);

  597. 	if( driver->bitdepth == 1000 ) {

  598. #if HAVE_CELT

  599. 	    // XXX: memory leak

  600. 	    CELTMode *celt_mode = celt_mode_create( driver->sample_rate, 1, driver->period_size, NULL );

  601. 	    driver->playback_srcs = jack_slist_append(driver->playback_srcs, celt_encoder_create( celt_mode ) );

  602. #endif

  603. 	} else {

  604. #if HAVE_SAMPLERATE

  605. 	    driver->playback_srcs = jack_slist_append(driver->playback_srcs, src_new(SRC_LINEAR, 1, NULL));

  606. #endif

  607. 	}

  608.     }

  609.     for (chn = driver->playback_channels_audio; chn < driver->playback_channels; chn++) {

  610.         snprintf (buf, sizeof(buf) - 1, "playback_%u", chn + 1);

  611. 

  612.         port = jack_port_register (driver->client, buf,

  613.                                    JACK_DEFAULT_MIDI_TYPE,

  614.                                    port_flags, 0);

  615. 

  616.         if (!port) {

  617.             jack_error ("NET: cannot register port for %s", buf);

  618.             break;

  619.         }

  620. 

  621.         driver->playback_ports =

  622.             jack_slist_append (driver->playback_ports, port);

  623.     }

  624. 

  625.     jack_activate (driver->client);

  626.     return 0;

  627. }

  628. 

  629. static int

  630. net_driver_detach (net_driver_t *driver)

  631. {

  632.     JSList * node;

  633. 

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

  635.         return 0;

  636. //#if 0

  637.     for (node = driver->capture_ports; node; node = jack_slist_next (node))

  638.         jack_port_unregister (driver->client,

  639.                               ((jack_port_t *) node->data));

  640. 

  641.     jack_slist_free (driver->capture_ports);

  642.     driver->capture_ports = NULL;

  643. //#endif

  644. 

  645.     for (node = driver->playback_ports; node; node = jack_slist_next (node))

  646.         jack_port_unregister (driver->client,

  647.                               ((jack_port_t *) node->data));

  648. 

  649.     jack_slist_free (driver->playback_ports);

  650.     driver->playback_ports = NULL;

  651. 

  652.     return 0;

  653. }

  654. 

  655. static void

  656. net_driver_delete (net_driver_t *driver)

  657. {

  658.     jack_driver_nt_finish ((jack_driver_nt_t *) driver);

  659.     free (driver);

  660. }

  661. 

  662. static jack_driver_t *

  663. net_driver_new (jack_client_t * client,

  664.                 char *name,

  665.                 unsigned int capture_ports,

  666.                 unsigned int playback_ports,

  667.                 unsigned int capture_ports_midi,

  668.                 unsigned int playback_ports_midi,

  669.                 jack_nframes_t sample_rate,

  670.                 jack_nframes_t period_size,

  671.                 unsigned int listen_port,

  672.                 unsigned int transport_sync,

  673.                 unsigned int resample_factor,

  674.                 unsigned int resample_factor_up,

  675.                 unsigned int bitdepth,

  676. 		unsigned int use_autoconfig,

  677. 		unsigned int latency,

  678. 		unsigned int redundancy,

  679. 		int always_wait_dedline,

  680. 		int dont_htonl_floats)

  681. {

  682.     net_driver_t * driver;

  683.     int first_pack_len;

  684.     struct sockaddr_in address;

  685. 

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

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

  688.             capture_ports, playback_ports, transport_sync);

  689. 

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

  691. 

  692.     jack_driver_nt_init ((jack_driver_nt_t *) driver);

  693. 

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

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

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

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

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

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

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

  701. 

  702.     // Fill in driver values.

  703.     // might be subject to autoconfig...

  704.     // so dont calculate anything with them...

  705. 

  706.     driver->sample_rate = sample_rate;

  707.     driver->period_size = period_size;

  708.     driver->dont_htonl_floats = dont_htonl_floats;

  709. 

  710.     driver->listen_port   = listen_port;

  711.     driver->last_wait_ust = 0;

  712. 

  713.     driver->capture_channels  = capture_ports + capture_ports_midi;

  714.     driver->capture_channels_audio  = capture_ports;

  715.     driver->capture_channels_midi   = capture_ports_midi;

  716.     driver->capture_ports     = NULL;

  717.     driver->playback_channels = playback_ports + playback_ports_midi;

  718.     driver->playback_channels_audio = playback_ports;

  719.     driver->playback_channels_midi = playback_ports_midi;

  720.     driver->playback_ports    = NULL;

  721.     driver->codec_latency = 0;

  722. 

  723.     driver->handle_transport_sync = transport_sync;

  724.     driver->mtu = 1400;

  725.     driver->latency = latency;

  726.     driver->redundancy = redundancy;

  727.     driver->always_wait_dedline = always_wait_dedline;

  728. 

  729. 

  730.     driver->client = client;

  731.     driver->engine = NULL;

  732. 

  733. 

  734.     if ((bitdepth != 0) && (bitdepth != 8) && (bitdepth != 16) && (bitdepth != 1000))

  735.     {

  736.         jack_info ("Invalid bitdepth: %d (8, 16 or 0 for float) !!!", bitdepth);

  737.         return NULL;

  738.     }

  739.     driver->bitdepth = bitdepth;

  740. 

  741. 

  742.     if (resample_factor_up == 0)

  743.         resample_factor_up = resample_factor;

  744. 

  745.     // Now open the socket, and wait for the first packet to arrive...

  746.     driver->sockfd = socket (PF_INET, SOCK_DGRAM, 0);

  747.     if (driver->sockfd == -1)

  748.     {

  749.         jack_info ("socket error");

  750.         return NULL;

  751.     }

  752.     address.sin_family = AF_INET;

  753.     address.sin_port = htons(driver->listen_port);

  754.     address.sin_addr.s_addr = htonl(INADDR_ANY);

  755.     if (bind (driver->sockfd, (struct sockaddr *) &address, sizeof (address)) < 0)

  756.     {

  757.         jack_info("bind error");

  758.         return NULL;

  759.     }

  760. 

  761.     driver->outsockfd = socket (PF_INET, SOCK_DGRAM, 0);

  762.     if (driver->outsockfd == -1)

  763.     {

  764.         jack_info ("socket error");

  765.         return NULL;

  766.     }

  767.     driver->srcaddress_valid = 0;

  768. 

  769.     if (use_autoconfig)

  770.     {

  771. 	jacknet_packet_header *first_packet = alloca (sizeof (jacknet_packet_header));

  772. 	socklen_t address_size = sizeof (struct sockaddr_in);

  773. 

  774. 	jack_info ("Waiting for an incoming packet !!!");

  775. 	jack_info ("*** IMPORTANT *** Dont connect a client to jackd until the driver is attached to a clock source !!!");

  776. 

  777. 	// XXX: netjack_poll polls forever.

  778. 	//      thats ok here.

  779. 	if (netjack_poll (driver->sockfd, 500))

  780. 	    first_pack_len = recvfrom (driver->sockfd, first_packet, sizeof (jacknet_packet_header), 0, (struct sockaddr*) & driver->syncsource_address, &address_size);

  781. 	else

  782. 	    first_pack_len = 0;

  783. 

  784. 	driver->srcaddress_valid = 1;

  785. 

  786. 	if (first_pack_len == sizeof (jacknet_packet_header))

  787. 	{

  788. 	    packet_header_ntoh (first_packet);

  789. 

  790. 	    jack_info ("AutoConfig Override !!!");

  791. 	    if (driver->sample_rate != first_packet->sample_rate)

  792. 	    {

  793. 		jack_info ("AutoConfig Override: Master JACK sample rate = %d", first_packet->sample_rate);

  794. 		driver->sample_rate = first_packet->sample_rate;

  795. 	    }

  796. 

  797. 	    if (driver->period_size != first_packet->period_size)

  798. 	    {

  799. 		jack_info ("AutoConfig Override: Master JACK period size is %d", first_packet->period_size);

  800. 		driver->period_size = first_packet->period_size;

  801. 	    }

  802. 	    if (driver->capture_channels_audio != first_packet->capture_channels_audio)

  803. 	    {

  804. 		jack_info ("AutoConfig Override: capture_channels_audio = %d", first_packet->capture_channels_audio);

  805. 		driver->capture_channels_audio = first_packet->capture_channels_audio;

  806. 	    }

  807. 	    if (driver->capture_channels_midi != first_packet->capture_channels_midi)

  808. 	    {

  809. 		jack_info ("AutoConfig Override: capture_channels_midi = %d", first_packet->capture_channels_midi);

  810. 		driver->capture_channels_midi = first_packet->capture_channels_midi;

  811. 	    }

  812. 	    if (driver->playback_channels_audio != first_packet->playback_channels_audio)

  813. 	    {

  814. 		jack_info ("AutoConfig Override: playback_channels_audio = %d", first_packet->playback_channels_audio);

  815. 		driver->playback_channels_audio = first_packet->playback_channels_audio;

  816. 	    }

  817. 	    if (driver->playback_channels_midi != first_packet->playback_channels_midi)

  818. 	    {

  819. 		jack_info ("AutoConfig Override: playback_channels_midi = %d", first_packet->playback_channels_midi);

  820. 		driver->playback_channels_midi = first_packet->playback_channels_midi;

  821. 	    }

  822. 

  823. 	    driver->mtu = first_packet->mtu;

  824. 	    jack_info ("MTU is set to %d bytes", first_packet->mtu);

  825. 	    driver->latency = first_packet->latency;

  826. 	}

  827.     }

  828.     driver->capture_channels  = driver->capture_channels_audio + driver->capture_channels_midi;

  829.     driver->playback_channels = driver->playback_channels_audio + driver->playback_channels_midi;

  830. 

  831.     // After possible Autoconfig: do all calculations...

  832.     driver->period_usecs =

  833.         (jack_time_t) floor ((((float) driver->period_size) / (float)driver->sample_rate)

  834.                              * 1000000.0f);

  835. 

  836.     if( driver->bitdepth == 1000 ) {

  837. 	// celt mode. 

  838. 	// TODO: this is a hack. But i dont want to change the packet header.

  839. 	driver->net_period_down = resample_factor;

  840. 	driver->net_period_up = resample_factor_up;

  841.     } else {

  842. 	driver->net_period_down = (float) driver->period_size / (float) resample_factor;

  843. 	driver->net_period_up = (float) driver->period_size / (float) resample_factor_up;

  844.     }

  845. 

  846.     driver->rx_bufsize = sizeof (jacknet_packet_header) + driver->net_period_down * driver->capture_channels * get_sample_size (driver->bitdepth);

  847.     driver->rx_buf = malloc (driver->rx_bufsize);

  848.     driver->pkt_buf = malloc (driver->rx_bufsize);

  849.     global_packcache = packet_cache_new (driver->latency + 5, driver->rx_bufsize, driver->mtu);

  850. 

  851.     driver->expected_framecnt_valid = 0;

  852.     driver->num_lost_packets = 0;

  853.     driver->next_deadline_valid = 0;

  854.     driver->deadline_goodness = 0;

  855.     driver->time_to_deadline = 0;

  856. 

  857.     // Special handling for latency=0

  858.     if( driver->latency == 0 )

  859. 	driver->resync_threshold = 0;

  860.     else

  861. 	driver->resync_threshold = MIN( 15, driver->latency-1 );

  862. 

  863.     driver->running_free = 0;

  864. 

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

  866.     jack_info ("netjack: framerate: %d", driver->sample_rate);

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

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

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

  870.     return (jack_driver_t *) driver;

  871. }

  872. 

  873. /* DRIVER "PLUGIN" INTERFACE */

  874. 

  875. jack_driver_desc_t *

  876. driver_get_descriptor ()

  877. {

  878.     jack_driver_desc_t * desc;

  879.     jack_driver_param_desc_t * params;

  880.     unsigned int i;

  881. 

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

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

  884.     desc->nparams = 17;

  885. 

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

  887. 

  888.     i = 0;

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

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

  891.     params[i].type       = JackDriverParamUInt;

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

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

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

  895. 

  896.     i++;

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

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

  899.     params[i].type       = JackDriverParamUInt;

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

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

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

  903. 

  904.     i++;

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

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

  907.     params[i].type       = JackDriverParamUInt;

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

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

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

  911. 

  912.     i++;

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

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

  915.     params[i].type       = JackDriverParamUInt;

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

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

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

  919. 

  920.     i++;

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

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

  923.     params[i].type       = JackDriverParamUInt;

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

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

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

  927. 

  928.     i++;

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

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

  931.     params[i].type       = JackDriverParamUInt;

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

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

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

  935. 

  936.     i++;

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

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

  939.     params[i].type       = JackDriverParamUInt;

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

  941.     strcpy (params[i].short_desc,

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

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

  944. 

  945.     i++;

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

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

  948.     params[i].type       = JackDriverParamUInt;

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

  950.     strcpy (params[i].short_desc,

  951.             "Factor for sample rate reduction");

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

  953. 

  954.     i++;

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

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

  957.     params[i].type       = JackDriverParamUInt;

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

  959.     strcpy (params[i].short_desc,

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

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

  962. 

  963.     i++;

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

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

  966.     params[i].type       = JackDriverParamUInt;

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

  968.     strcpy (params[i].short_desc,

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

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

  971. 

  972.     i++;

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

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

  975.     params[i].type       = JackDriverParamUInt;

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

  977.     strcpy (params[i].short_desc,

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

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

  980. 

  981.     i++;

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

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

  984.     params[i].type       = JackDriverParamUInt;

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

  986.     strcpy (params[i].short_desc,

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

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

  989. 

  990.     i++;

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

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

  993.     params[i].type       = JackDriverParamUInt;

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

  995.     strcpy (params[i].short_desc,

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

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

  998. 

  999.     i++;

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

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

  1002.     params[i].type       = JackDriverParamUInt;

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

  1004.     strcpy (params[i].short_desc,

  1005.             "Latency setting");

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

  1007. 

  1008.     i++;

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

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

  1011.     params[i].type       = JackDriverParamUInt;

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

  1013.     strcpy (params[i].short_desc,

  1014.             "Send packets N times");

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

  1016. 

  1017.     i++;

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

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

  1020.     params[i].type       = JackDriverParamUInt;

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

  1022.     strcpy (params[i].short_desc,

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

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

  1025. 

  1026.     i++;

  1027.     strcpy (params[i].name, "deadline");

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

  1029.     params[i].type       = JackDriverParamBool;

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

  1031.     strcpy (params[i].short_desc,

  1032.             "always wait for the deadline, more friendly to alsa_io");

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

  1034. 

  1035.     desc->params = params;

  1036. 

  1037.     return desc;

  1038. }

  1039. 

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

  1041. 

  1042. jack_driver_t *

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

  1044. {

  1045.     jack_nframes_t sample_rate = 48000;

  1046.     jack_nframes_t resample_factor = 1;

  1047.     jack_nframes_t period_size = 1024;

  1048.     unsigned int capture_ports = 2;

  1049.     unsigned int playback_ports = 2;

  1050.     unsigned int capture_ports_midi = 1;

  1051.     unsigned int playback_ports_midi = 1;

  1052.     unsigned int listen_port = 3000;

  1053.     unsigned int resample_factor_up = 0;

  1054.     unsigned int bitdepth = 0;

  1055.     unsigned int handle_transport_sync = 1;

  1056.     unsigned int use_autoconfig = 1;

  1057.     unsigned int latency = 5;

  1058.     unsigned int redundancy = 1;

  1059.     int dont_htonl_floats = 0;

  1060.     int always_wait_dedline = 0;

  1061.     const JSList * node;

  1062.     const jack_driver_param_t * param;

  1063. 

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

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

  1066. 

  1067.         switch (param->character) {

  1068. 

  1069.             case 'i':

  1070.                 capture_ports = param->value.ui;

  1071.                 break;

  1072. 

  1073.             case 'o':

  1074.                 playback_ports = param->value.ui;

  1075.                 break;

  1076. 

  1077.             case 'I':

  1078.                 capture_ports_midi = param->value.ui;

  1079.                 break;

  1080. 

  1081.             case 'O':

  1082.                 playback_ports_midi = param->value.ui;

  1083.                 break;

  1084. 

  1085.             case 'r':

  1086.                 sample_rate = param->value.ui;

  1087.                 break;

  1088. 

  1089.             case 'p':

  1090.                 period_size = param->value.ui;

  1091.                 break;

  1092. 

  1093.             case 'l':

  1094.                 listen_port = param->value.ui;

  1095.                 break;

  1096. 

  1097.             case 'f':

  1098. #if HAVE_SAMPLERATE

  1099.                 resample_factor = param->value.ui;

  1100. #else

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

  1102. 		exit(10);

  1103. #endif

  1104.                 break;

  1105. 

  1106.             case 'u':

  1107. #if HAVE_SAMPLERATE

  1108.                 resample_factor_up = param->value.ui;

  1109. #else

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

  1111. 		exit(10);

  1112. #endif

  1113.                 break;

  1114. 

  1115.             case 'b':

  1116.                 bitdepth = param->value.ui;

  1117.                 break;

  1118. 

  1119. 	    case 'c':

  1120. #if HAVE_CELT

  1121. 		bitdepth = 1000;

  1122. 		resample_factor = param->value.ui;

  1123. #else

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

  1125. 		exit(10);

  1126. #endif

  1127. 		break;

  1128. 

  1129.             case 't':

  1130.                 handle_transport_sync = param->value.ui;

  1131.                 break;

  1132. 

  1133.             case 'a':

  1134.                 use_autoconfig = param->value.ui;

  1135.                 break;

  1136. 

  1137.             case 'L':

  1138.                 latency = param->value.ui;

  1139.                 break;

  1140. 

  1141.             case 'R':

  1142.                 redundancy = param->value.ui;

  1143.                 break;

  1144. 

  1145.             case 'H':

  1146.                 dont_htonl_floats = param->value.ui;

  1147.                 break;

  1148. 

  1149.             case 'D':

  1150.                 always_wait_dedline = param->value.ui;

  1151.                 break;

  1152.         }

  1153.     }

  1154. 

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

  1156.                            capture_ports_midi, playback_ports_midi,

  1157.                            sample_rate, period_size,

  1158.                            listen_port, handle_transport_sync,

  1159.                            resample_factor, resample_factor_up, bitdepth,

  1160. 			   use_autoconfig, latency, redundancy,

  1161. 			   always_wait_dedline, dont_htonl_floats);

  1162. }

  1163. 

  1164. void

  1165. driver_finish (jack_driver_t *driver)

  1166. {

  1167.     net_driver_delete ((net_driver_t *) driver);

  1168. }