jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 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.
1754 Commits
8 Branches
68MB
Tree: 2d00ac0eaf
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2d00ac0eaf'
${ noResults }
jack2/common/JackNetOneDriver.cpp

1126 lines
37KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2001 Paul Davis

  3. Copyright (C) 2008 Romain Moret at Grame

  4. 

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

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

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

  8. (at your option) any later version.

  9. 

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

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

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

  13. GNU General Public License for more details.

  14. 

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

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

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

  18. */

  19. 

  20. #define HAVE_CELT 1

  21. 

  22. #ifdef WIN32

  23. #include <malloc.h>

  24. #endif

  25. 

  26. #include "JackNetOneDriver.h"

  27. #include "JackEngineControl.h"

  28. #include "JackGraphManager.h"

  29. #include "JackWaitThreadedDriver.h"

  30. #include "JackException.h"

  31. #include "driver_interface.h"

  32. 

  33. #include "netjack.h"

  34. #include "netjack_packet.h"

  35. 

  36. #if HAVE_SAMPLERATE

  37. #include "samplerate.h"

  38. #endif

  39. 

  40. #if HAVE_CELT

  41. #include "celt/celt.h"

  42. #endif

  43. 

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

  45. 

  46. using namespace std;

  47. 

  48. namespace Jack

  49. {

  50.     JackNetOneDriver::JackNetOneDriver ( const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table,

  51.                                    int port, int mtu, int capture_ports, int playback_ports, int midi_input_ports, int midi_output_ports,

  52. 				   int sample_rate, int period_size, int resample_factor,

  53.                                    char* net_name, uint transport_sync, int bitdepth, int use_autoconfig,

  54. 				   int latency, int redundancy, int dont_htonl_floats, int always_deadline )

  55.             : JackAudioDriver ( name, alias, engine, table )

  56.     {

  57.         jack_log ( "JackNetOneDriver::JackNetOneDriver port %d", port );

  58. 

  59. #ifdef WIN32

  60.     WSADATA wsa;

  61.     int rc = WSAStartup(MAKEWORD(2,0),&wsa);

  62. #endif

  63. 

  64. 	netjack_init( & (this->netj),

  65. 		NULL, // client

  66.                 name,

  67.                 capture_ports,

  68.                 playback_ports,

  69.                 midi_input_ports,

  70.                 midi_output_ports,

  71.                 sample_rate,

  72.                 period_size,

  73.                 port,

  74.                 transport_sync,

  75.                 resample_factor,

  76.                 0,

  77.                 bitdepth,

  78. 		use_autoconfig,

  79. 		latency,

  80. 		redundancy,

  81. 		dont_htonl_floats,

  82. 		always_deadline);

  83.     }

  84. 

  85.     JackNetOneDriver::~JackNetOneDriver()

  86.     {

  87. 	// No destructor yet.

  88.     }

  89. 

  90. //open, close, attach and detach------------------------------------------------------

  91.     int JackNetOneDriver::Open ( jack_nframes_t buffer_size, jack_nframes_t samplerate, bool capturing, bool playing,

  92.                               int inchannels, int outchannels, bool monitor,

  93.                               const char* capture_driver_name, const char* playback_driver_name,

  94.                               jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  95.     {

  96.         if ( JackAudioDriver::Open ( buffer_size,

  97.                                      samplerate,

  98.                                      capturing,

  99.                                      playing,

  100.                                      inchannels,

  101.                                      outchannels,

  102.                                      monitor,

  103.                                      capture_driver_name,

  104.                                      playback_driver_name,

  105.                                      capture_latency,

  106.                                      playback_latency ) == 0 )

  107.         {

  108.             fEngineControl->fPeriod = 0;

  109.             fEngineControl->fComputation = 500 * 1000;

  110.             fEngineControl->fConstraint = 500 * 1000;

  111.             return 0;

  112.         }

  113.         else

  114.         {

  115.             jack_error( "open fail\n" );

  116.             return -1;

  117.         }

  118.     }

  119. 

  120.     int JackNetOneDriver::Close()

  121.     {

  122.         FreePorts();

  123.         netjack_release( &netj );

  124.         return JackDriver::Close();

  125.     }

  126. 

  127.     int JackNetOneDriver::Attach()

  128.     {

  129.         return 0;

  130.     }

  131. 

  132.     int JackNetOneDriver::Detach()

  133.     {

  134.         return 0;

  135.     }

  136. 

  137.     int JackNetOneDriver::AllocPorts()

  138.     {

  139. 	jack_port_id_t port_id;

  140. 	char buf[64];

  141. 	unsigned int chn;

  142. 	int port_flags;

  143. 

  144. 

  145. 	//if (netj.handle_transport_sync)

  146. 	//    jack_set_sync_callback(netj.client, (JackSyncCallback) net_driver_sync_cb, NULL);

  147. 

  148. 	port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  149. 

  150. 	for (chn = 0; chn < netj.capture_channels_audio; chn++) {

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

  152. 

  153.             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, buf, JACK_DEFAULT_AUDIO_TYPE,

  154.                              static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )

  155.             {

  156.                 jack_error ( "driver: cannot register port for %s", buf );

  157.                 return -1;

  158.             }

  159.             //port = fGraphManager->GetPort ( port_id );

  160. 

  161. 	    netj.capture_ports =

  162. 		jack_slist_append (netj.capture_ports, (void *)(intptr_t)port_id);

  163. 

  164. 	    if( netj.bitdepth == CELT_MODE ) {

  165. #if HAVE_CELT

  166. #if HAVE_CELT_API_0_7

  167. 	    celt_int32 lookahead;

  168. 	    CELTMode *celt_mode = celt_mode_create( netj.sample_rate, netj.period_size, NULL );

  169. 	    netj.capture_srcs = jack_slist_append(netj.capture_srcs, celt_decoder_create( celt_mode, 1, NULL ) );

  170. #else

  171. 	    celt_int32_t lookahead;

  172. 	    CELTMode *celt_mode = celt_mode_create( netj.sample_rate, 1, netj.period_size, NULL );

  173. 	    netj.capture_srcs = jack_slist_append(netj.capture_srcs, celt_decoder_create( celt_mode ) );

  174. #endif

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

  176. 	    netj.codec_latency = 2*lookahead;

  177. #endif

  178. 	    } else {

  179. #if HAVE_SAMPLERATE

  180. 		netj.capture_srcs = jack_slist_append(netj.capture_srcs, (void *)src_new(SRC_LINEAR, 1, NULL));

  181. #endif

  182. 	    }

  183. 	}

  184. 	for (chn = netj.capture_channels_audio; chn < netj.capture_channels; chn++) {

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

  186. 

  187.             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, buf, JACK_DEFAULT_MIDI_TYPE,

  188.                              static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )

  189.             {

  190.                 jack_error ( "driver: cannot register port for %s", buf );

  191.                 return -1;

  192.             }

  193.             //port = fGraphManager->GetPort ( port_id );

  194. 

  195. 	    netj.capture_ports =

  196. 		jack_slist_append (netj.capture_ports, (void *)(intptr_t)port_id);

  197. 	}

  198. 

  199. 	port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  200. 

  201. 	for (chn = 0; chn < netj.playback_channels_audio; chn++) {

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

  203. 

  204.             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, buf, JACK_DEFAULT_AUDIO_TYPE,

  205.                              static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )

  206.             {

  207.                 jack_error ( "driver: cannot register port for %s", buf );

  208.                 return -1;

  209.             }

  210.             //port = fGraphManager->GetPort ( port_id );

  211. 

  212. 	    netj.playback_ports =

  213. 		jack_slist_append (netj.playback_ports, (void *)(intptr_t)port_id);

  214. 

  215. 	    if( netj.bitdepth == CELT_MODE ) {

  216. #if HAVE_CELT

  217. #if HAVE_CELT_API_0_7

  218. 	    CELTMode *celt_mode = celt_mode_create( netj.sample_rate, netj.period_size, NULL );

  219. 	    netj.playback_srcs = jack_slist_append(netj.playback_srcs, celt_encoder_create( celt_mode, 1, NULL ) );

  220. #else

  221. 	    CELTMode *celt_mode = celt_mode_create( netj.sample_rate, 1, netj.period_size, NULL );

  222. 	    netj.playback_srcs = jack_slist_append(netj.playback_srcs, celt_encoder_create( celt_mode ) );

  223. #endif

  224. #endif

  225. 	    } else {

  226. #if HAVE_SAMPLERATE

  227. 		netj.playback_srcs = jack_slist_append(netj.playback_srcs, (void *)src_new(SRC_LINEAR, 1, NULL));

  228. #endif

  229. 	    }

  230. 	}

  231. 	for (chn = netj.playback_channels_audio; chn < netj.playback_channels; chn++) {

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

  233. 

  234.             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, buf, JACK_DEFAULT_MIDI_TYPE,

  235.                              static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )

  236.             {

  237.                 jack_error ( "driver: cannot register port for %s", buf );

  238.                 return -1;

  239.             }

  240.             //port = fGraphManager->GetPort ( port_id );

  241. 

  242. 	    netj.playback_ports =

  243. 		jack_slist_append (netj.playback_ports, (void *)(intptr_t)port_id);

  244. 	}

  245. 	return 0;

  246.     }

  247. 

  248. //init and restart--------------------------------------------------------------------

  249.     bool JackNetOneDriver::Initialize()

  250.     {

  251.         jack_log ( "JackNetOneDriver::Init()" );

  252. 

  253. 	if( global_packcache != NULL ) {

  254. 	    FreePorts();

  255. 	    netjack_release( &netj );

  256. 	}

  257. 

  258.         //display some additional infos

  259.         jack_info ( "NetOne driver started" );

  260. 	if( netjack_startup( &netj ) ) {

  261. 	    return false;

  262. 	}

  263. 

  264.         //register jack ports

  265.         if ( AllocPorts() != 0 )

  266.         {

  267.             jack_error ( "Can't allocate ports." );

  268.             return false;

  269.         }

  270. 

  271. 

  272.         //monitor

  273.         //driver parametering

  274.         JackAudioDriver::SetBufferSize ( netj.period_size );

  275.         JackAudioDriver::SetSampleRate ( netj.sample_rate );

  276. 

  277.         JackDriver::NotifyBufferSize ( netj.period_size );

  278.         JackDriver::NotifySampleRate ( netj.sample_rate );

  279. 

  280.         //transport engine parametering

  281.         fEngineControl->fTransport.SetNetworkSync ( true );

  282.         return true;

  283.     }

  284. 

  285. 

  286. //jack ports and buffers--------------------------------------------------------------

  287. 

  288. //driver processes--------------------------------------------------------------------

  289.     int JackNetOneDriver::Read()

  290.     {

  291. 	netjack_wait( &netj );

  292. 

  293. 	if( (netj.num_lost_packets * netj.period_size / netj.sample_rate) > 10 )

  294. 	    throw JackNetException();

  295. 

  296. 	//netjack_read( &netj, netj.period_size );

  297.         JackDriver::CycleTakeBeginTime();

  298. 

  299. 	jack_position_t local_trans_pos;

  300. 	jack_transport_state_t local_trans_state;

  301. 

  302. 	unsigned int *packet_buf, *packet_bufX;

  303. 

  304. 	if( ! netj.packet_data_valid ) {

  305.             jack_log( "data not valid" );

  306. 	    render_payload_to_jack_ports (netj.bitdepth, NULL, netj.net_period_down, netj.capture_ports, netj.capture_srcs, netj.period_size, netj.dont_htonl_floats );

  307. 	    return 0;

  308. 	}

  309. 	packet_buf = netj.rx_buf;

  310. 

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

  312. 

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

  314. 

  315. 	netj.reply_port = pkthdr->reply_port;

  316. 	netj.latency = pkthdr->latency;

  317. 

  318. 	// Special handling for latency=0

  319. 	if( netj.latency == 0 )

  320. 	    netj.resync_threshold = 0;

  321. 	else

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

  323. 

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

  325. 	if (netj.handle_transport_sync) {

  326. #if 1

  327. 	    unsigned int compensated_tranport_pos = (pkthdr->transport_frame + (pkthdr->latency * netj.period_size) + netj.codec_latency);

  328. 

  329. 	    // read local transport info....

  330. 	    //local_trans_state = jack_transport_query(netj.client, &local_trans_pos);

  331. 

  332.             local_trans_state = fEngineControl->fTransport.Query ( &local_trans_pos );

  333. 

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

  335. 	    switch (pkthdr->transport_state) {

  336. 		case JackTransportStarting:

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

  338. 		    if (local_trans_state == JackTransportStopped) {

  339. 			fEngineControl->fTransport.SetCommand ( TransportCommandStart );

  340. 			//jack_transport_start(netj.client);

  341. 			//last_transport_state = JackTransportStopped;

  342. 			netj.sync_state = 0;

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

  344. 		    }

  345. 

  346. 		    if (local_trans_pos.frame != compensated_tranport_pos)

  347. 		    {

  348. 			jack_position_t new_pos = local_trans_pos;

  349. 			new_pos.frame = compensated_tranport_pos + 2*netj.period_size;

  350. 			new_pos.valid = (jack_position_bits_t) 0;

  351. 

  352. 

  353. 			fEngineControl->fTransport.RequestNewPos ( &new_pos );

  354. 			//jack_transport_locate(netj.client, compensated_tranport_pos);

  355. 			//last_transport_state = JackTransportRolling;

  356. 			netj.sync_state = 0;

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

  358. 		    }

  359. 		    break;

  360. 		case JackTransportStopped:

  361. 		    netj.sync_state = 1;

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

  363. 			jack_position_t new_pos = local_trans_pos;

  364. 			new_pos.frame = pkthdr->transport_frame;

  365. 			new_pos.valid = (jack_position_bits_t)0;

  366. 			fEngineControl->fTransport.RequestNewPos ( &new_pos );

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

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

  369. 		    }

  370. 		    if (local_trans_state != JackTransportStopped)

  371. 			//jack_transport_stop(netj.client);

  372. 			fEngineControl->fTransport.SetCommand ( TransportCommandStop );

  373. 		    break;

  374. 		case JackTransportRolling:

  375. 		    netj.sync_state = 1;

  376. 		    //		    		if(local_trans_pos.frame != (pkthdr->transport_frame + (pkthdr->latency) * netj.period_size)) {

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

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

  379. 		    //		    		}

  380. 		    if (local_trans_state != JackTransportRolling)

  381. 			//jack_transport_start (netj.client);

  382. 			fEngineControl->fTransport.SetState ( JackTransportRolling );

  383. 

  384. 		    break;

  385. 

  386. 		case JackTransportLooping:

  387. 		    break;

  388. 	    }

  389. #endif

  390. 	}

  391. 

  392. 	render_payload_to_jack_ports (netj.bitdepth, packet_bufX, netj.net_period_down, netj.capture_ports, netj.capture_srcs, netj.period_size, netj.dont_htonl_floats );

  393. 	packet_cache_release_packet(global_packcache, netj.expected_framecnt );

  394. 	return 0;

  395.     }

  396. 

  397.     int JackNetOneDriver::Write()

  398.     {

  399. 	int syncstate = netj.sync_state | ((fEngineControl->fTransport.GetState() == JackTransportNetStarting) ? 1 : 0 );

  400. 	//netjack_write( &netj, netj.period_size, 0 );

  401. 	uint32_t *packet_buf, *packet_bufX;

  402. 

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

  404. 	jacknet_packet_header *pkthdr;

  405. 

  406. 	packet_buf = (uint32_t *) alloca(packet_size);

  407. 	pkthdr = (jacknet_packet_header *)packet_buf;

  408. 

  409. 	if( netj.running_free ) {

  410. 	    return 0;

  411. 	}

  412. 

  413. 	// offset packet_bufX by the packetheader.

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

  415. 

  416. 	pkthdr->sync_state = syncstate;;

  417. 	pkthdr->latency = netj.time_to_deadline;

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

  419. 	pkthdr->framecnt = netj.expected_framecnt;

  420. 

  421. 

  422. 	render_jack_ports_to_payload(netj.bitdepth, netj.playback_ports, netj.playback_srcs, netj.period_size, packet_bufX, netj.net_period_up, netj.dont_htonl_floats );

  423. 

  424. 	packet_header_hton(pkthdr);

  425. 	if (netj.srcaddress_valid)

  426. 	{

  427. 	    unsigned int r;

  428. 

  429. #ifdef __APPLE__

  430. 	    static const int flag = 0;

  431. #else

  432. 	    static const int flag = 0;

  433. #endif

  434. 

  435. 	    if (netj.reply_port)

  436. 		netj.syncsource_address.sin_port = htons(netj.reply_port);

  437. 

  438. 	    for( r=0; r<netj.redundancy; r++ )

  439. 		netjack_sendto(netj.outsockfd, (char *)packet_buf, packet_size,

  440. 			flag, (struct sockaddr*)&(netj.syncsource_address), sizeof(struct sockaddr_in), netj.mtu);

  441. 	}

  442. 	return 0;

  443.     }

  444. 

  445. void

  446. JackNetOneDriver::FreePorts ()

  447. {

  448.     JSList *node = netj.capture_ports;

  449. 

  450.     while( node != NULL ) {

  451. 	JSList *this_node = node;

  452. 	jack_port_id_t port_id = (jack_port_id_t)(intptr_t) node->data;

  453. 	node = jack_slist_remove_link( node, this_node );

  454. 	jack_slist_free_1( this_node );

  455. 	fGraphManager->ReleasePort( fClientControl.fRefNum, port_id );

  456.     }

  457.     netj.capture_ports = NULL;

  458. 

  459.     node = netj.playback_ports;

  460.     while( node != NULL ) {

  461. 	JSList *this_node = node;

  462. 	jack_port_id_t port_id = (jack_port_id_t)(intptr_t) node->data;

  463. 	node = jack_slist_remove_link( node, this_node );

  464. 	jack_slist_free_1( this_node );

  465. 	fGraphManager->ReleasePort( fClientControl.fRefNum, port_id );

  466.     }

  467.     netj.playback_ports = NULL;

  468. 

  469.     if( netj.bitdepth == CELT_MODE ) {

  470. #if HAVE_CELT

  471. 	node = netj.playback_srcs;

  472. 	while( node != NULL ) {

  473. 	    JSList *this_node = node;

  474. 	    CELTEncoder *enc = (CELTEncoder *) node->data;

  475. 	    node = jack_slist_remove_link( node, this_node );

  476. 	    jack_slist_free_1( this_node );

  477. 	    celt_encoder_destroy( enc );

  478. 	}

  479. 	netj.playback_srcs = NULL;

  480. 

  481. 	node = netj.capture_srcs;

  482. 	while( node != NULL ) {

  483. 	    JSList *this_node = node;

  484. 	    CELTDecoder *dec = (CELTDecoder *) node->data;

  485. 	    node = jack_slist_remove_link( node, this_node );

  486. 	    jack_slist_free_1( this_node );

  487. 	    celt_decoder_destroy( dec );

  488. 	}

  489. 	netj.capture_srcs = NULL;

  490. #endif

  491.     } else {

  492. #if HAVE_SAMPLERATE

  493. 	node = netj.playback_srcs;

  494. 	while( node != NULL ) {

  495. 	    JSList *this_node = node;

  496. 	    SRC_STATE *state = (SRC_STATE *) node->data;

  497. 	    node = jack_slist_remove_link( node, this_node );

  498. 	    jack_slist_free_1( this_node );

  499. 	    src_delete( state );

  500. 	}

  501. 	netj.playback_srcs = NULL;

  502. 

  503. 	node = netj.capture_srcs;

  504. 	while( node != NULL ) {

  505. 	    JSList *this_node = node;

  506. 	    SRC_STATE *state = (SRC_STATE *) node->data;

  507. 	    node = jack_slist_remove_link( node, this_node );

  508. 	    jack_slist_free_1( this_node );

  509. 	    src_delete( state );

  510. 	}

  511. 	netj.capture_srcs = NULL;

  512. #endif

  513.     }

  514. }

  515. //Render functions--------------------------------------------------------------------

  516. 

  517. // render functions for float

  518. void

  519. JackNetOneDriver::render_payload_to_jack_ports_float ( void *packet_payload, jack_nframes_t net_period_down, JSList *capture_ports, JSList *capture_srcs, jack_nframes_t nframes, int dont_htonl_floats)

  520. {

  521.     uint32_t chn = 0;

  522.     JSList *node = capture_ports;

  523. #if HAVE_SAMPLERATE

  524.     JSList *src_node = capture_srcs;

  525. #endif

  526. 

  527.     uint32_t *packet_bufX = (uint32_t *)packet_payload;

  528. 

  529.     if( !packet_payload )

  530. 	return;

  531. 

  532.     while (node != NULL)

  533.     {

  534.         unsigned int i;

  535.         int_float_t val;

  536. #if HAVE_SAMPLERATE

  537.         SRC_DATA src;

  538. #endif

  539. 

  540. 	jack_port_id_t port_id = (jack_port_id_t)(intptr_t) node->data;

  541. 	JackPort *port = fGraphManager->GetPort( port_id );

  542. 

  543.         jack_default_audio_sample_t* buf =

  544.             (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_id, fEngineControl->fBufferSize);

  545. 

  546.         const char *porttype = port->GetType();

  547. 

  548.         if (strncmp (porttype, JACK_DEFAULT_AUDIO_TYPE, jack_port_type_size()) == 0)

  549.         {

  550. #if HAVE_SAMPLERATE

  551.             // audio port, resample if necessary

  552.             if (net_period_down != nframes)

  553.             {

  554.                 SRC_STATE *src_state = (SRC_STATE *)src_node->data;

  555.                 for (i = 0; i < net_period_down; i++)

  556.                 {

  557.                     packet_bufX[i] = ntohl (packet_bufX[i]);

  558.                 }

  559. 

  560.                 src.data_in = (float *) packet_bufX;

  561.                 src.input_frames = net_period_down;

  562. 

  563.                 src.data_out = buf;

  564.                 src.output_frames = nframes;

  565. 

  566.                 src.src_ratio = (float) nframes / (float) net_period_down;

  567.                 src.end_of_input = 0;

  568. 

  569.                 src_set_ratio (src_state, src.src_ratio);

  570.                 src_process (src_state, &src);

  571.                 src_node = jack_slist_next (src_node);

  572.             }

  573.             else

  574. #endif

  575.             {

  576. 		if( dont_htonl_floats )

  577. 		{

  578. 		    memcpy( buf, packet_bufX, net_period_down*sizeof(jack_default_audio_sample_t));

  579. 		}

  580. 		else

  581. 		{

  582. 		    for (i = 0; i < net_period_down; i++)

  583. 		    {

  584. 			val.i = packet_bufX[i];

  585. 			val.i = ntohl (val.i);

  586. 			buf[i] = val.f;

  587. 		    }

  588. 		}

  589.             }

  590.         }

  591.         else if (strncmp (porttype, JACK_DEFAULT_MIDI_TYPE, jack_port_type_size()) == 0)

  592.         {

  593.             // midi port, decode midi events

  594.             // convert the data buffer to a standard format (uint32_t based)

  595.             unsigned int buffer_size_uint32 = net_period_down;

  596.             uint32_t * buffer_uint32 = (uint32_t*)packet_bufX;

  597.             decode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);

  598.         }

  599.         packet_bufX = (packet_bufX + net_period_down);

  600.         node = jack_slist_next (node);

  601.         chn++;

  602.     }

  603. }

  604. 

  605. void

  606. JackNetOneDriver::render_jack_ports_to_payload_float (JSList *playback_ports, JSList *playback_srcs, jack_nframes_t nframes, void *packet_payload, jack_nframes_t net_period_up, int dont_htonl_floats )

  607. {

  608.     uint32_t chn = 0;

  609.     JSList *node = playback_ports;

  610. #if HAVE_SAMPLERATE

  611.     JSList *src_node = playback_srcs;

  612. #endif

  613. 

  614.     uint32_t *packet_bufX = (uint32_t *) packet_payload;

  615. 

  616.     while (node != NULL)

  617.     {

  618. #if HAVE_SAMPLERATE

  619.         SRC_DATA src;

  620. #endif

  621.         unsigned int i;

  622.         int_float_t val;

  623. 	jack_port_id_t port_id = (jack_port_id_t)(intptr_t) node->data;

  624. 	JackPort *port = fGraphManager->GetPort( port_id );

  625. 

  626.         jack_default_audio_sample_t* buf =

  627.             (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_id, fEngineControl->fBufferSize);

  628. 

  629.         const char *porttype = port->GetType();

  630. 

  631.         if (strncmp (porttype, JACK_DEFAULT_AUDIO_TYPE, jack_port_type_size()) == 0)

  632.         {

  633.             // audio port, resample if necessary

  634. 

  635. #if HAVE_SAMPLERATE

  636.             if (net_period_up != nframes) {

  637.                 SRC_STATE *src_state = (SRC_STATE *) src_node->data;

  638.                 src.data_in = buf;

  639.                 src.input_frames = nframes;

  640. 

  641.                 src.data_out = (float *) packet_bufX;

  642.                 src.output_frames = net_period_up;

  643. 

  644.                 src.src_ratio = (float) net_period_up / (float) nframes;

  645.                 src.end_of_input = 0;

  646. 

  647.                 src_set_ratio (src_state, src.src_ratio);

  648.                 src_process (src_state, &src);

  649. 

  650.                 for (i = 0; i < net_period_up; i++)

  651.                 {

  652.                     packet_bufX[i] = htonl (packet_bufX[i]);

  653.                 }

  654.                 src_node = jack_slist_next (src_node);

  655.             }

  656.             else

  657. #endif

  658.             {

  659. 		if( dont_htonl_floats )

  660. 		{

  661. 		    memcpy( packet_bufX, buf, net_period_up*sizeof(jack_default_audio_sample_t) );

  662. 		}

  663. 		else

  664. 		{

  665. 		    for (i = 0; i < net_period_up; i++)

  666. 		    {

  667. 			val.f = buf[i];

  668. 			val.i = htonl (val.i);

  669. 			packet_bufX[i] = val.i;

  670. 		    }

  671. 		}

  672.             }

  673.         }

  674.         else if (strncmp(porttype, JACK_DEFAULT_MIDI_TYPE, jack_port_type_size()) == 0)

  675.         {

  676.             // encode midi events from port to packet

  677.             // convert the data buffer to a standard format (uint32_t based)

  678.             unsigned int buffer_size_uint32 = net_period_up;

  679.             uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;

  680.             encode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);

  681.         }

  682.         packet_bufX = (packet_bufX + net_period_up);

  683.         node = jack_slist_next (node);

  684.         chn++;

  685.     }

  686. }

  687. 

  688. #if HAVE_CELT

  689. // render functions for celt.

  690. void

  691. JackNetOneDriver::render_payload_to_jack_ports_celt (void *packet_payload, jack_nframes_t net_period_down, JSList *capture_ports, JSList *capture_srcs, jack_nframes_t nframes)

  692. {

  693.     uint32_t chn = 0;

  694.     JSList *node = capture_ports;

  695.     JSList *src_node = capture_srcs;

  696. 

  697.     unsigned char *packet_bufX = (unsigned char *)packet_payload;

  698. 

  699.     while (node != NULL)

  700.     {

  701. 	jack_port_id_t port_id = (jack_port_id_t) (intptr_t)node->data;

  702. 	JackPort *port = fGraphManager->GetPort( port_id );

  703. 

  704.         jack_default_audio_sample_t* buf =

  705.             (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_id, fEngineControl->fBufferSize);

  706. 

  707.         const char *portname = port->GetType();

  708. 

  709. 

  710.         if (strncmp(portname, JACK_DEFAULT_AUDIO_TYPE, jack_port_type_size()) == 0)

  711.         {

  712.             // audio port, decode celt data.

  713. 

  714. 	    CELTDecoder *decoder = (CELTDecoder *)src_node->data;

  715. 	    if( !packet_payload )

  716. 		celt_decode_float( decoder, NULL, net_period_down, buf );

  717. 	    else

  718. 		celt_decode_float( decoder, packet_bufX, net_period_down, buf );

  719. 

  720. 	    src_node = jack_slist_next (src_node);

  721.         }

  722.         else if (strncmp(portname, JACK_DEFAULT_MIDI_TYPE, jack_port_type_size()) == 0)

  723.         {

  724.             // midi port, decode midi events

  725.             // convert the data buffer to a standard format (uint32_t based)

  726.             unsigned int buffer_size_uint32 = net_period_down / 2;

  727.             uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;

  728. 	    if( packet_payload )

  729. 		decode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);

  730.         }

  731.         packet_bufX = (packet_bufX + net_period_down);

  732.         node = jack_slist_next (node);

  733.         chn++;

  734.     }

  735. }

  736. 

  737. void

  738. JackNetOneDriver::render_jack_ports_to_payload_celt (JSList *playback_ports, JSList *playback_srcs, jack_nframes_t nframes, void *packet_payload, jack_nframes_t net_period_up)

  739. {

  740.     uint32_t chn = 0;

  741.     JSList *node = playback_ports;

  742.     JSList *src_node = playback_srcs;

  743. 

  744.     unsigned char *packet_bufX = (unsigned char *)packet_payload;

  745. 

  746.     while (node != NULL)

  747.     {

  748. 	jack_port_id_t port_id = (jack_port_id_t) (intptr_t) node->data;

  749. 	JackPort *port = fGraphManager->GetPort( port_id );

  750. 

  751.         jack_default_audio_sample_t* buf =

  752.             (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_id, fEngineControl->fBufferSize);

  753. 

  754.         const char *portname = port->GetType();

  755. 

  756.         if (strncmp (portname, JACK_DEFAULT_AUDIO_TYPE, jack_port_type_size()) == 0)

  757.         {

  758.             // audio port, encode celt data.

  759. 

  760. 	    int encoded_bytes;

  761. 	    float *floatbuf = (float *)alloca (sizeof(float) * nframes );

  762. 	    memcpy( floatbuf, buf, nframes*sizeof(float) );

  763. 	    CELTEncoder *encoder = (CELTEncoder *)src_node->data;

  764. 	    encoded_bytes = celt_encode_float( encoder, floatbuf, NULL, packet_bufX, net_period_up );

  765. 	    if( encoded_bytes != (int)net_period_up )

  766. 		jack_error( "something in celt changed. netjack needs to be changed to handle this.\n" );

  767. 	    src_node = jack_slist_next( src_node );

  768.         }

  769.         else if (strncmp(portname, JACK_DEFAULT_MIDI_TYPE, jack_port_type_size()) == 0)

  770.         {

  771.             // encode midi events from port to packet

  772.             // convert the data buffer to a standard format (uint32_t based)

  773.             unsigned int buffer_size_uint32 = net_period_up / 2;

  774.             uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;

  775.             encode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);

  776.         }

  777.         packet_bufX = (packet_bufX + net_period_up);

  778.         node = jack_slist_next (node);

  779.         chn++;

  780.     }

  781. }

  782. 

  783. #endif

  784. /* Wrapper functions with bitdepth argument... */

  785. void

  786. JackNetOneDriver::render_payload_to_jack_ports (int bitdepth, void *packet_payload, jack_nframes_t net_period_down, JSList *capture_ports, JSList *capture_srcs, jack_nframes_t nframes, int dont_htonl_floats)

  787. {

  788. #if HAVE_CELT

  789.     if (bitdepth == CELT_MODE)

  790.         render_payload_to_jack_ports_celt (packet_payload, net_period_down, capture_ports, capture_srcs, nframes);

  791.     else

  792. #endif

  793.         render_payload_to_jack_ports_float (packet_payload, net_period_down, capture_ports, capture_srcs, nframes, dont_htonl_floats);

  794. }

  795. 

  796. void

  797. JackNetOneDriver::render_jack_ports_to_payload (int bitdepth, JSList *playback_ports, JSList *playback_srcs, jack_nframes_t nframes, void *packet_payload, jack_nframes_t net_period_up, int dont_htonl_floats)

  798. {

  799. #if HAVE_CELT

  800.     if (bitdepth == CELT_MODE)

  801.         render_jack_ports_to_payload_celt (playback_ports, playback_srcs, nframes, packet_payload, net_period_up);

  802.     else

  803. #endif

  804.         render_jack_ports_to_payload_float (playback_ports, playback_srcs, nframes, packet_payload, net_period_up, dont_htonl_floats);

  805. }

  806. 

  807. 

  808. 

  809. //driver loader-----------------------------------------------------------------------

  810. 

  811. #ifdef __cplusplus

  812.     extern "C"

  813.     {

  814. #endif

  815.         SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor ()

  816. 	{

  817. 	    jack_driver_desc_t* desc = ( jack_driver_desc_t* ) calloc ( 1, sizeof ( jack_driver_desc_t ) );

  818. 	    jack_driver_param_desc_t * params;

  819. 

  820. 	    strcpy ( desc->name, "netone" );                             // size MUST be less then JACK_DRIVER_NAME_MAX + 1

  821. 	    strcpy ( desc->desc, "netjack one slave backend component" ); // size MUST be less then JACK_DRIVER_PARAM_DESC + 1

  822. 

  823. 	    desc->nparams = 17;

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

  825. 

  826. 	    int i = 0;

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

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

  829. 	    params[i].type       = JackDriverParamUInt;

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

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

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

  833. 

  834. 	    i++;

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

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

  837. 	    params[i].type       = JackDriverParamUInt;

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

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

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

  841. 

  842. 	    i++;

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

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

  845. 	    params[i].type       = JackDriverParamUInt;

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

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

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

  849. 

  850. 	    i++;

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

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

  853. 	    params[i].type       = JackDriverParamUInt;

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

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

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

  857. 

  858. 	    i++;

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

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

  861. 	    params[i].type       = JackDriverParamUInt;

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

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

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

  865. 

  866. 	    i++;

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

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

  869. 	    params[i].type       = JackDriverParamUInt;

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

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

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

  873. 

  874. 	    i++;

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

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

  877. 	    params[i].type       = JackDriverParamUInt;

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

  879. 	    strcpy (params[i].short_desc,

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

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

  882. 

  883. 	    i++;

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

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

  886. 	    params[i].type       = JackDriverParamUInt;

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

  888. 	    strcpy (params[i].short_desc,

  889. 		    "Factor for sample rate reduction");

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

  891. 

  892. 	    i++;

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

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

  895. 	    params[i].type       = JackDriverParamUInt;

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

  897. 	    strcpy (params[i].short_desc,

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

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

  900. 

  901. 	    i++;

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

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

  904. 	    params[i].type       = JackDriverParamUInt;

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

  906. 	    strcpy (params[i].short_desc,

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

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

  909. 

  910. 	    i++;

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

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

  913. 	    params[i].type       = JackDriverParamUInt;

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

  915. 	    strcpy (params[i].short_desc,

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

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

  918. 

  919. 	    i++;

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

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

  922. 	    params[i].type       = JackDriverParamBool;

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

  924. 	    strcpy (params[i].short_desc,

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

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

  927. 

  928. 	    i++;

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

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

  931. 	    params[i].type       = JackDriverParamBool;

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

  933. 	    strcpy (params[i].short_desc,

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

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

  936. 

  937. 	    i++;

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

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

  940. 	    params[i].type       = JackDriverParamUInt;

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

  942. 	    strcpy (params[i].short_desc,

  943. 		    "Latency setting");

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

  945. 

  946. 	    i++;

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

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

  949. 	    params[i].type       = JackDriverParamUInt;

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

  951. 	    strcpy (params[i].short_desc,

  952. 		    "Send packets N times");

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

  954. 

  955. 	    i++;

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

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

  958. 	    params[i].type       = JackDriverParamBool;

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

  960. 	    strcpy (params[i].short_desc,

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

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

  963. 

  964. 	    i++;

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

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

  967. 	    params[i].type       = JackDriverParamBool;

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

  969. 	    strcpy (params[i].short_desc,

  970. 		    "always use deadline (recommended for internet connect)");

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

  972. 

  973. 	    desc->params = params;

  974. 

  975. 	    return desc;

  976. 	}

  977. 

  978.         SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize ( Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params )

  979.         {

  980.     jack_nframes_t sample_rate = 48000;

  981.     jack_nframes_t resample_factor = 1;

  982.     jack_nframes_t period_size = 1024;

  983.     unsigned int capture_ports = 2;

  984.     unsigned int playback_ports = 2;

  985.     unsigned int capture_ports_midi = 1;

  986.     unsigned int playback_ports_midi = 1;

  987.     unsigned int listen_port = 3000;

  988.     unsigned int resample_factor_up = 0;

  989.     unsigned int bitdepth = 0;

  990.     unsigned int handle_transport_sync = 1;

  991.     unsigned int use_autoconfig = 1;

  992.     unsigned int latency = 5;

  993.     unsigned int redundancy = 1;

  994.     unsigned int mtu = 1400;

  995.     int dont_htonl_floats = 0;

  996.     int always_deadline = 0;

  997.     const JSList * node;

  998.     const jack_driver_param_t * param;

  999. 

  1000. 

  1001. 

  1002.             for ( node = params; node; node = jack_slist_next ( node ) )

  1003.             {

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

  1005.                 switch ( param->character )

  1006.                 {

  1007.             case 'i':

  1008.                 capture_ports = param->value.ui;

  1009.                 break;

  1010. 

  1011.             case 'o':

  1012.                 playback_ports = param->value.ui;

  1013.                 break;

  1014. 

  1015.             case 'I':

  1016.                 capture_ports_midi = param->value.ui;

  1017.                 break;

  1018. 

  1019.             case 'O':

  1020.                 playback_ports_midi = param->value.ui;

  1021.                 break;

  1022. 

  1023.             case 'r':

  1024.                 sample_rate = param->value.ui;

  1025.                 break;

  1026. 

  1027.             case 'p':

  1028.                 period_size = param->value.ui;

  1029.                 break;

  1030. 

  1031.             case 'l':

  1032.                 listen_port = param->value.ui;

  1033.                 break;

  1034. 

  1035.             case 'f':

  1036. #if HAVE_SAMPLERATE

  1037.                 resample_factor = param->value.ui;

  1038. #else

  1039. 		jack_error( "not built with libsamplerate support\n" );

  1040. 		exit(10);

  1041. #endif

  1042.                 break;

  1043. 

  1044.             case 'u':

  1045. #if HAVE_SAMPLERATE

  1046.                 resample_factor_up = param->value.ui;

  1047. #else

  1048. 		jack_error( "not built with libsamplerate support\n" );

  1049. 		exit(10);

  1050. #endif

  1051.                 break;

  1052. 

  1053.             case 'b':

  1054.                 bitdepth = param->value.ui;

  1055.                 break;

  1056. 

  1057. 	    case 'c':

  1058. #if HAVE_CELT

  1059. 		bitdepth = CELT_MODE;

  1060. 		resample_factor = param->value.ui;

  1061. #else

  1062. 		jack_error( "not built with celt support\n" );

  1063. 		exit(10);

  1064. #endif

  1065. 		break;

  1066. 

  1067.             case 't':

  1068.                 handle_transport_sync = param->value.ui;

  1069.                 break;

  1070. 

  1071.             case 'a':

  1072.                 use_autoconfig = param->value.ui;

  1073.                 break;

  1074. 

  1075.             case 'L':

  1076.                 latency = param->value.ui;

  1077.                 break;

  1078. 

  1079.             case 'R':

  1080.                 redundancy = param->value.ui;

  1081.                 break;

  1082. 

  1083.             case 'H':

  1084.                 dont_htonl_floats = param->value.ui;

  1085.                 break;

  1086. 

  1087.             case 'D':

  1088.                 always_deadline = param->value.ui;

  1089.                 break;

  1090.                 }

  1091.             }

  1092. 

  1093.             try

  1094.             {

  1095. 

  1096.                 Jack::JackDriverClientInterface* driver =

  1097.                     new Jack::JackWaitThreadedDriver (

  1098.                     new Jack::JackNetOneDriver ( "system", "net_pcm", engine, table, listen_port, mtu,

  1099.                                               capture_ports_midi, playback_ports_midi, capture_ports, playback_ports,

  1100. 					      sample_rate, period_size, resample_factor,

  1101. 					      "net_pcm", handle_transport_sync, bitdepth, use_autoconfig, latency, redundancy, 

  1102. 					      dont_htonl_floats, always_deadline ) );

  1103. 

  1104.                 if ( driver->Open ( period_size, sample_rate, 1, 1, capture_ports, playback_ports,

  1105.                                     0, "from_master_", "to_master_", 0, 0 ) == 0 )

  1106.                 {

  1107.                     return driver;

  1108.                 }

  1109.                 else

  1110.                 {

  1111.                     delete driver;

  1112.                     return NULL;

  1113.                 }

  1114. 

  1115.             }

  1116.             catch ( ... )

  1117.             {

  1118.                 return NULL;

  1119.             }

  1120.         }

  1121. 

  1122. #ifdef __cplusplus

  1123.     }

  1124. #endif

  1125. }