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.
1071 Commits
8 Branches
398MB
Tree: d30ff96fa2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd30ff96fa2'
${ noResults }
jack2/common/JackNetDriver.cpp

713 lines
24KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2001 Paul Davis

  3. Copyright (C) 2008 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. 

  21. #include "JackNetDriver.h"

  22. #include "JackEngineControl.h"

  23. #include "JackClientControl.h"

  24. #include "JackGraphManager.h"

  25. #include "driver_interface.h"

  26. #include "JackDriverLoader.h"

  27. #include "JackThreadedDriver.h"

  28. #include "JackWaitThreadedDriver.h"

  29. #include "JackException.h"

  30. #include "JackExports.h"

  31. 

  32. #define DEFAULT_MULTICAST_IP "225.3.19.154"

  33. #define DEFAULT_PORT 19000

  34. 

  35. namespace Jack

  36. {

  37. 	JackNetDriver::JackNetDriver ( const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table,

  38. 	                               const char* ip, int port, int mtu, int midi_input_ports, int midi_output_ports, const char* net_name )

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

  40. 	{

  41. 		fMulticastIP = new char[strlen ( ip ) + 1];

  42. 		strcpy ( fMulticastIP, ip );

  43. 		fUDPPort = port;

  44. 		fParams.fMtu = mtu;

  45. 		fParams.fSendMidiChannels = midi_input_ports;

  46. 		fParams.fReturnMidiChannels = midi_output_ports;

  47. 		strcpy ( fParams.fName, net_name );

  48. 		fSockfd = 0;

  49. 	}

  50. 

  51. 	JackNetDriver::~JackNetDriver()

  52. 	{

  53. 		if ( fSockfd )

  54. 			close ( fSockfd );

  55. 		delete fNetAudioCaptureBuffer;

  56. 		delete fNetAudioPlaybackBuffer;

  57. 		delete fNetMidiCaptureBuffer;

  58. 		delete fNetMidiPlaybackBuffer;

  59. 		delete[] fTxBuffer;

  60. 		delete[] fRxBuffer;

  61. 		delete[] fMulticastIP;

  62. 		delete[] fMidiCapturePortList;

  63. 		delete[] fMidiPlaybackPortList;

  64. 	}

  65. 

  66. //*************************************initialization***********************************************************************

  67. 

  68. 	int JackNetDriver::Open ( jack_nframes_t nframes, jack_nframes_t samplerate, bool capturing, bool playing,

  69. 	                          int inchannels, int outchannels, bool monitor,

  70. 	                          const char* capture_driver_name, const char* playback_driver_name,

  71. 	                          jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  72. 	{

  73. 		int res = JackAudioDriver::Open ( nframes, samplerate, capturing, playing, inchannels, outchannels, monitor,

  74. 		                                  capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  75. 		fEngineControl->fPeriod = 0;

  76. 		fEngineControl->fComputation = 500 * 1000;

  77. 		fEngineControl->fConstraint = 500 * 1000;

  78. 		return res;

  79. 	}

  80. 

  81. 	int JackNetDriver::Attach()

  82. 	{

  83. 		return 0;

  84. 	}

  85. 

  86. 	int JackNetDriver::Detach()

  87. 	{

  88. 		return 0;

  89. 	}

  90. 

  91. 	bool JackNetDriver::Init()

  92. 	{

  93. 		jack_log ( "JackNetDriver::Init()" );

  94. 		if ( fSockfd )

  95. 			Restart();

  96. 

  97. 		//set the parameters to send

  98. 		strcpy ( fParams.fPacketType, "params" );

  99. 		fParams.fProtocolVersion = 'a';

  100. 		SetPacketType ( &fParams, SLAVE_AVAILABLE );

  101. 		gethostname ( fParams.fSlaveNetName, 255 );

  102. 		fParams.fSendAudioChannels = fCaptureChannels;

  103. 		fParams.fReturnAudioChannels = fPlaybackChannels;

  104. 

  105. 		//init loop : get a master and start, do it until connection is ok

  106. 		net_status_t status;

  107. 		do

  108. 		{

  109. 			//first, get a master, do it until a valid connection is running

  110. 			jack_info ( "Initializing Net Driver..." );

  111. 			do

  112. 			{

  113. 				status = GetNetMaster();

  114. 				if ( status == SOCKET_ERROR )

  115. 					return false;

  116. 			}

  117. 			while ( status != CONNECTED );

  118. 

  119. 			//then tell the master we are ready

  120. 			jack_info ( "Initializing connection with %s...", fParams.fMasterNetName );

  121. 			status = SendMasterStartSync();

  122. 			if ( status == NET_ERROR )

  123. 				return false;

  124. 		}

  125. 		while ( status != ROLLING );

  126. 

  127. 		//driver parametering

  128. 		if ( SetParams() )

  129. 		{

  130. 			jack_error ( "Fatal error : can't alloc net driver ports." );

  131. 			return false;

  132. 		}

  133. 

  134. 		//init done, display parameters

  135. 		SessionParamsDisplay ( &fParams );

  136. 

  137. 		return true;

  138. 	}

  139. 

  140. 	net_status_t JackNetDriver::GetNetMaster()

  141. 	{

  142. 		jack_log ( "JackNetDriver::GetNetMaster()" );

  143. 		//utility

  144. 		session_params_t params;

  145. 		struct sockaddr_in mcast_addr, listen_addr;

  146. 		struct timeval rcv_timeout;

  147. 		rcv_timeout.tv_sec = 2;

  148. 		rcv_timeout.tv_usec = 0;

  149. 		socklen_t addr_len = sizeof ( socket_address_t );

  150. 		int rx_bytes = 0;

  151. 

  152. 		//set the multicast address

  153. 		mcast_addr.sin_family = AF_INET;

  154. 		mcast_addr.sin_port = htons ( fUDPPort );

  155. 		inet_aton ( fMulticastIP, &mcast_addr.sin_addr );

  156. 		memset ( &mcast_addr.sin_zero, 0, 8 );

  157. 

  158. 		//set the listening address

  159. 		listen_addr.sin_family = AF_INET;

  160. 		listen_addr.sin_port = htons ( fUDPPort );

  161. 		listen_addr.sin_addr.s_addr = htonl ( INADDR_ANY );

  162. 		memset ( &listen_addr.sin_zero, 0, 8 );

  163. 

  164. 		//set the master address family

  165. 		fMasterAddr.sin_family = AF_INET;

  166. 

  167. 		//socket

  168. 		if ( fSockfd )

  169. 			close ( fSockfd );

  170. 		if ( ( fSockfd = socket ( AF_INET, SOCK_DGRAM, 0 ) ) < 0 )

  171. 		{

  172. 			jack_error ( "Fatal error : network unreachable - %s", strerror ( errno ) );

  173. 			return SOCKET_ERROR;

  174. 		}

  175. 

  176. 		//bind the socket

  177. 		if ( bind ( fSockfd, reinterpret_cast<socket_address_t*> ( &listen_addr ), addr_len )  < 0 )

  178. 			jack_error ( "Can't bind the socket : %s", strerror ( errno ) );

  179. 

  180. 		//timeout on receive

  181. 		setsockopt ( fSockfd, SOL_SOCKET, SO_RCVTIMEO, &rcv_timeout, sizeof ( rcv_timeout ) );

  182. 

  183. 		//send 'AVAILABLE' until 'SLAVE_SETUP' received

  184. 		jack_info ( "Waiting for a master..." );

  185. 		do

  186. 		{

  187. 			//send 'available'

  188. 			if ( sendto ( fSockfd, &fParams, sizeof ( session_params_t ), 0,

  189. 			              reinterpret_cast<socket_address_t*> ( &mcast_addr ), addr_len ) < 0 )

  190. 				jack_error ( "Error in data send : %s", strerror ( errno ) );

  191. 			//filter incoming packets : don't exit while receiving wrong packets

  192. 			do

  193. 			{

  194. 				rx_bytes = recvfrom ( fSockfd, &params, sizeof ( session_params_t ), 0,

  195. 				                      reinterpret_cast<socket_address_t*> ( &fMasterAddr ), &addr_len );

  196. 				if ( ( rx_bytes < 0 ) && ( errno != EAGAIN ) )

  197. 				{

  198. 					jack_error ( "Can't receive : %s", strerror ( errno ) );

  199. 					return RECV_ERROR;

  200. 				}

  201. 			}

  202. 			while ( ( rx_bytes > 0 )  && strcmp ( params.fPacketType, fParams.fPacketType ) );

  203. 		}

  204. 		while ( ( GetPacketType ( &params ) != SLAVE_SETUP ) );

  205. 

  206. 		//connect the socket

  207. 		if ( connect ( fSockfd, reinterpret_cast<socket_address_t*> ( &fMasterAddr ), sizeof ( socket_address_t ) )  < 0 )

  208. 		{

  209. 			jack_error ( "Error in connect : %s", strerror ( errno ) );

  210. 			return CONNECT_ERROR;

  211. 		}

  212. 

  213. 		//everything is OK, copy parameters and return

  214. 		fParams = params;

  215. 

  216. 		return CONNECTED;

  217. 	}

  218. 

  219. 	net_status_t JackNetDriver::SendMasterStartSync()

  220. 	{

  221. 		jack_log ( "JackNetDriver::GetNetMasterStartSync()" );

  222. 		//tell the master to start

  223. 		SetPacketType ( &fParams, START_MASTER );

  224. 		if ( send ( fSockfd, &fParams, sizeof ( session_params_t ), 0 ) < 0 )

  225. 		{

  226. 			jack_error ( "Error in send : %s", strerror ( errno ) );

  227. 			return ( ( errno == ECONNABORTED ) || ( errno == ECONNREFUSED ) || ( errno == ECONNRESET ) ) ? NET_ERROR : SEND_ERROR;

  228. 		}

  229. 		return ROLLING;

  230. 	}

  231. 

  232. 	void JackNetDriver::Restart()

  233. 	{

  234. 		jack_info ( "Restarting driver..." );

  235. 		close ( fSockfd );

  236. 		delete[] fTxBuffer;

  237. 		delete[] fRxBuffer;

  238. 		delete fNetAudioCaptureBuffer;

  239. 		delete fNetAudioPlaybackBuffer;

  240. 		delete fNetMidiCaptureBuffer;

  241. 		delete fNetMidiPlaybackBuffer;

  242. 		FreePorts();

  243. 		delete[] fMidiCapturePortList;

  244. 		delete[] fMidiPlaybackPortList;

  245. 		fTxBuffer = NULL;

  246. 		fRxBuffer = NULL;

  247. 		fNetAudioCaptureBuffer = NULL;

  248. 		fNetAudioPlaybackBuffer = NULL;

  249. 		fNetMidiCaptureBuffer = NULL;

  250. 		fNetMidiPlaybackBuffer = NULL;

  251. 		fMidiCapturePortList = NULL;

  252. 		fMidiPlaybackPortList = NULL;

  253. 	}

  254. 

  255. 	int JackNetDriver::SetParams()

  256. 	{

  257. 		fNSubProcess = fParams.fPeriodSize / fParams.fFramesPerPacket;

  258. 		JackAudioDriver::SetBufferSize(fParams.fPeriodSize);

  259. 		JackAudioDriver::SetSampleRate(fParams.fSampleRate);

  260.         

  261.         JackDriver::NotifyBufferSize(fParams.fPeriodSize);

  262.         JackDriver::NotifySampleRate(fParams.fSampleRate);

  263. 

  264. 		//allocate midi ports lists

  265. 		fMidiCapturePortList = new jack_port_id_t [fParams.fSendMidiChannels];

  266. 		fMidiPlaybackPortList = new jack_port_id_t [fParams.fReturnMidiChannels];

  267. 

  268. 		//register jack ports

  269. 		if ( AllocPorts() != 0 )

  270. 		{

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

  272. 			return -1;

  273. 		}

  274. 

  275. 		//TX header init

  276. 		strcpy ( fTxHeader.fPacketType, "header" );

  277. 		fTxHeader.fDataStream = 'r';

  278. 		fTxHeader.fID = fParams.fID;

  279. 		fTxHeader.fCycle = 0;

  280. 		fTxHeader.fSubCycle = 0;

  281. 		fTxHeader.fMidiDataSize = 0;

  282. 		fTxHeader.fBitdepth = fParams.fBitdepth;

  283. 

  284. 		//RX header init

  285. 		strcpy ( fRxHeader.fPacketType, "header" );

  286. 		fRxHeader.fDataStream = 's';

  287. 		fRxHeader.fID = fParams.fID;

  288. 		fRxHeader.fCycle = 0;

  289. 		fRxHeader.fSubCycle = 0;

  290. 		fRxHeader.fMidiDataSize = 0;

  291. 		fRxHeader.fBitdepth = fParams.fBitdepth;

  292. 

  293. 		//network buffers

  294. 		fTxBuffer = new char[fParams.fMtu];

  295. 		fRxBuffer = new char[fParams.fMtu];

  296. 

  297. 		//net audio/midi buffers

  298. 		fTxData = fTxBuffer + sizeof ( packet_header_t );

  299. 		fRxData = fRxBuffer + sizeof ( packet_header_t );

  300. 

  301. 		//midi net buffers

  302. 		fNetMidiCaptureBuffer = new NetMidiBuffer ( &fParams, fParams.fSendMidiChannels, fRxData );

  303. 		fNetMidiPlaybackBuffer = new NetMidiBuffer ( &fParams, fParams.fReturnMidiChannels, fTxData );

  304. 

  305. 		//audio net buffers

  306. 		fNetAudioCaptureBuffer = new NetAudioBuffer ( &fParams, fParams.fSendAudioChannels, fRxData );

  307. 		fNetAudioPlaybackBuffer = new NetAudioBuffer ( &fParams, fParams.fReturnAudioChannels, fTxData );

  308. 

  309. 		//audio netbuffer length

  310. 		fAudioTxLen = sizeof ( packet_header_t ) + fNetAudioPlaybackBuffer->GetSize();

  311. 		fAudioRxLen = sizeof ( packet_header_t ) + fNetAudioCaptureBuffer->GetSize();

  312. 

  313. 		return 0;

  314. 	}

  315. 

  316. 	int JackNetDriver::AllocPorts()

  317. 	{

  318. 		jack_log ( "JackNetDriver::AllocPorts fBufferSize = %ld fSampleRate = %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate );

  319. 		JackPort* port;

  320. 		jack_port_id_t port_id;

  321. 		char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  322. 		char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  323. 		unsigned long port_flags;

  324. 

  325. 		//audio

  326. 		port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  327. 		for ( int port_index = 0; port_index < fCaptureChannels; port_index++ )

  328. 		{

  329. 			snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:out%d", fAliasName, fCaptureDriverName, port_index + 1 );

  330. 			snprintf ( name, sizeof ( name ) - 1, "%s:capture_%d", fClientControl.fName, port_index + 1 );

  331. 			if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE,

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

  333. 			{

  334. 				jack_error ( "driver: cannot register port for %s", name );

  335. 				return -1;

  336. 			}

  337. 			port = fGraphManager->GetPort ( port_id );

  338. 			port->SetAlias ( alias );

  339. 			port->SetLatency ( fEngineControl->fBufferSize + fCaptureLatency );

  340. 			fCapturePortList[port_index] = port_id;

  341. 			jack_log ( "JackNetDriver::AllocPorts() fCapturePortList[%d] port_index = %ld", port_index, port_id );

  342. 		}

  343. 		port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  344. 		for ( int port_index = 0; port_index < fPlaybackChannels; port_index++ )

  345. 		{

  346. 			snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:in%d", fAliasName, fPlaybackDriverName, port_index + 1 );

  347. 			snprintf ( name, sizeof ( name ) - 1, "%s:playback_%d",fClientControl.fName, port_index + 1 );

  348. 			if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE,

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

  350. 			{

  351. 				jack_error ( "driver: cannot register port for %s", name );

  352. 				return -1;

  353. 			}

  354. 			port = fGraphManager->GetPort ( port_id );

  355. 			port->SetAlias ( alias );

  356. 			port->SetLatency ( fEngineControl->fBufferSize + ( ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize ) + fPlaybackLatency );

  357. 			fPlaybackPortList[port_index] = port_id;

  358. 			jack_log ( "JackNetDriver::AllocPorts() fPlaybackPortList[%d] port_index = %ld", port_index, port_id );

  359. 		}

  360. 		//midi

  361. 		port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  362. 		for ( uint port_index = 0; port_index < fParams.fSendMidiChannels; port_index++ )

  363. 		{

  364. 			snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:out%d", fAliasName, fCaptureDriverName, port_index + 1 );

  365. 			snprintf ( name, sizeof ( name ) - 1, "%s:midi_capture_%d", fClientControl.fName, port_index + 1 );

  366. 			if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_MIDI_TYPE,

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

  368. 			{

  369. 				jack_error ( "driver: cannot register port for %s", name );

  370. 				return -1;

  371. 			}

  372. 			fMidiCapturePortList[port_index] = port_id;

  373. 			jack_log ( "JackNetDriver::AllocPorts() fMidiCapturePortList[%d] port_index = %ld", port_index, port_id );

  374. 		}

  375. 

  376. 		port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  377. 		for ( uint port_index = 0; port_index < fParams.fReturnMidiChannels; port_index++ )

  378. 		{

  379. 			snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:in%d", fAliasName, fPlaybackDriverName, port_index + 1 );

  380. 			snprintf ( name, sizeof ( name ) - 1, "%s:midi_playback_%d", fClientControl.fName, port_index + 1 );

  381. 			if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_MIDI_TYPE,

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

  383. 			{

  384. 				jack_error ( "driver: cannot register port for %s", name );

  385. 				return -1;

  386. 			}

  387. 			fMidiPlaybackPortList[port_index] = port_id;

  388. 			jack_log ( "JackNetDriver::AllocPorts() fMidiPlaybackPortList[%d] port_index = %ld", port_index, port_id );

  389. 		}

  390. 

  391. 		return 0;

  392. 	}

  393. 

  394. 	int JackNetDriver::FreePorts()

  395. 	{

  396. 		jack_log ( "JackNetDriver::FreePorts" );

  397. 		for ( int port_index = 0; port_index < fCaptureChannels; port_index++ )

  398. 			fGraphManager->ReleasePort ( fClientControl.fRefNum, fCapturePortList[port_index] );

  399. 		for ( int port_index = 0; port_index < fPlaybackChannels; port_index++ )

  400. 			fGraphManager->ReleasePort ( fClientControl.fRefNum, fPlaybackPortList[port_index] );

  401. 		for ( uint port_index = 0; port_index < fParams.fSendMidiChannels; port_index++ )

  402. 			fGraphManager->ReleasePort ( fClientControl.fRefNum, fMidiCapturePortList[port_index] );

  403. 		for ( uint port_index = 0; port_index < fParams.fReturnMidiChannels; port_index++ )

  404. 			fGraphManager->ReleasePort ( fClientControl.fRefNum, fMidiPlaybackPortList[port_index] );

  405. 		return 0;

  406. 	}

  407. 

  408. 	JackMidiBuffer* JackNetDriver::GetMidiInputBuffer ( int port_index )

  409. 	{

  410. 		return static_cast<JackMidiBuffer*> ( fGraphManager->GetBuffer ( fMidiCapturePortList[port_index], fEngineControl->fBufferSize ) );

  411. 	}

  412. 

  413. 	JackMidiBuffer* JackNetDriver::GetMidiOutputBuffer ( int port_index )

  414. 	{

  415. 		return static_cast<JackMidiBuffer*> ( fGraphManager->GetBuffer ( fMidiPlaybackPortList[port_index], fEngineControl->fBufferSize ) );

  416. 	}

  417. 

  418. 	int JackNetDriver::Recv ( size_t size, int flags )

  419. 	{

  420. 		int rx_bytes;

  421. 		if ( ( rx_bytes = recv ( fSockfd, fRxBuffer, size, flags ) ) < 0 )

  422. 		{

  423. 			if ( errno == EAGAIN )

  424. 			{

  425. 				jack_error ( "No incoming data, is the master still running ?" );

  426. 				return 0;

  427. 			}

  428. 			else if ( ( errno == ECONNABORTED ) || ( errno == ECONNREFUSED ) || ( errno == ECONNRESET ) )

  429. 			{

  430. 				jack_error ( "Fatal error : %s.", strerror ( errno ) );

  431. 				throw JackDriverException();

  432. 			}

  433. 			else

  434. 			{

  435. 				jack_error ( "Error in receive : %s", strerror ( errno ) );

  436. 				return 0;

  437. 			}

  438. 		}

  439. 		return rx_bytes;

  440. 	}

  441. 

  442. 	int JackNetDriver::Send ( size_t size, int flags )

  443. 	{

  444. 		int tx_bytes;

  445. 		if ( ( tx_bytes = send ( fSockfd, fTxBuffer, size, flags ) ) < 0 )

  446. 		{

  447. 			if ( ( errno == ECONNABORTED ) || ( errno == ECONNREFUSED ) || ( errno == ECONNRESET ) )

  448. 			{

  449. 				jack_error ( "Fatal error : %s.", strerror ( errno ) );

  450. 				throw JackDriverException();

  451. 			}

  452. 			else

  453. 				jack_error ( "Error in send : %s", strerror ( errno ) );

  454. 		}

  455. 		return tx_bytes;

  456. 	}

  457. 

  458. //*************************************process************************************************************************

  459. 

  460. 	int JackNetDriver::Read()

  461. 	{

  462. 		int rx_bytes;

  463. 		uint recvd_midi_pckt = 0;

  464. 		packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );

  465. 		fRxHeader.fIsLastPckt = 'n';

  466. 

  467. 		//buffers

  468. 		for ( uint port_index = 0; port_index < fParams.fSendMidiChannels; port_index++ )

  469. 			fNetMidiCaptureBuffer->fPortBuffer[port_index] = GetMidiInputBuffer ( port_index );

  470. 		for ( int port_index = 0; port_index < fCaptureChannels; port_index++ )

  471. 			fNetAudioCaptureBuffer->fPortBuffer[port_index] = GetInputBuffer ( port_index );

  472. 

  473. 		//receive sync (launch the cycle)

  474. 		do

  475. 		{

  476. 			if ( ( rx_bytes = Recv ( sizeof ( packet_header_t ), 0 ) ) < 1 )

  477. 				return rx_bytes;

  478. 		}

  479. 		while ( !rx_bytes && ( rx_head->fDataType != 's' ) );

  480. 

  481. 		JackDriver::CycleTakeBeginTime();

  482. 

  483. 		//audio, midi or sync if driver is late

  484. 		if ( fParams.fSendMidiChannels || fParams.fSendAudioChannels )

  485. 		{

  486. 			do

  487. 			{

  488. 				rx_bytes = Recv ( fParams.fMtu, MSG_PEEK );

  489. 				if ( rx_bytes < 1 )

  490. 					return rx_bytes;

  491. 				if ( rx_bytes && ( rx_head->fDataStream == 's' ) && ( rx_head->fID == fParams.fID ) )

  492. 				{

  493. 					switch ( rx_head->fDataType )

  494. 					{

  495. 						case 'm':	//midi

  496. 							rx_bytes = Recv ( rx_bytes, MSG_DONTWAIT );

  497. 							fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

  498. 							fNetMidiCaptureBuffer->RenderFromNetwork ( rx_head->fSubCycle, rx_bytes - sizeof ( packet_header_t ) );

  499. 							if ( ++recvd_midi_pckt == rx_head->fNMidiPckt )

  500. 								fNetMidiCaptureBuffer->RenderToJackPorts();

  501. 							break;

  502. 						case 'a':	//audio

  503. 							rx_bytes = Recv ( fAudioRxLen, MSG_DONTWAIT );

  504. 							if ( !IsNextPacket ( &fRxHeader, rx_head, fNSubProcess ) )

  505. 								jack_error ( "Packet(s) missing..." );

  506. 							fRxHeader.fCycle = rx_head->fCycle;

  507. 							fRxHeader.fSubCycle = rx_head->fSubCycle;

  508. 							fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

  509. 							fNetAudioCaptureBuffer->RenderToJackPorts ( rx_head->fSubCycle );

  510. 							break;

  511. 						case 's':	//sync

  512. 							jack_info ( "NetDriver : driver overloaded, skipping receive." );

  513. 							fRxHeader.fCycle = rx_head->fCycle;

  514. 							return 0;

  515. 					}

  516. 				}

  517. 			}

  518. 			while ( fRxHeader.fIsLastPckt != 'y' );

  519. 		}

  520. 		fRxHeader.fCycle = rx_head->fCycle;

  521. 		return 0;

  522. 	}

  523. 

  524. 	int JackNetDriver::Write()

  525. 	{

  526. 		int tx_bytes, copy_size;

  527. 		fTxHeader.fCycle = fRxHeader.fCycle;

  528. 		fTxHeader.fSubCycle = 0;

  529. 		fTxHeader.fIsLastPckt = 'n';

  530. 

  531. 		//buffers

  532. 		for ( uint port_index = 0; port_index < fParams.fReturnMidiChannels; port_index++ )

  533. 			fNetMidiPlaybackBuffer->fPortBuffer[port_index] = GetMidiOutputBuffer ( port_index );

  534. 		for ( int port_index = 0; port_index < fPlaybackChannels; port_index++ )

  535. 			fNetAudioPlaybackBuffer->fPortBuffer[port_index] = GetOutputBuffer ( port_index );

  536. 

  537. 		//midi

  538. 		if ( fParams.fReturnMidiChannels )

  539. 		{

  540. 			fTxHeader.fDataType = 'm';

  541. 			fTxHeader.fMidiDataSize = fNetMidiPlaybackBuffer->RenderFromJackPorts();

  542. 			fTxHeader.fNMidiPckt = GetNMidiPckt ( &fParams, fTxHeader.fMidiDataSize );

  543. 			for ( uint subproc = 0; subproc < fTxHeader.fNMidiPckt; subproc++ )

  544. 			{

  545. 				fTxHeader.fSubCycle = subproc;

  546. 				if ( ( subproc == ( fTxHeader.fNMidiPckt - 1 ) ) && !fParams.fReturnAudioChannels )

  547. 					fTxHeader.fIsLastPckt = 'y';

  548. 				memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );

  549. 				copy_size = fNetMidiPlaybackBuffer->RenderToNetwork ( subproc, fTxHeader.fMidiDataSize );

  550. 				tx_bytes = Send ( sizeof ( packet_header_t ) + copy_size, 0 );

  551. 			}

  552. 		}

  553. 

  554. 		//audio

  555. 		if ( fParams.fReturnAudioChannels )

  556. 		{

  557. 			fTxHeader.fDataType = 'a';

  558. 			for ( uint subproc = 0; subproc < fNSubProcess; subproc++ )

  559. 			{

  560. 				fTxHeader.fSubCycle = subproc;

  561. 				if ( subproc == ( fNSubProcess - 1 ) )

  562. 					fTxHeader.fIsLastPckt = 'y';

  563. 				fNetAudioPlaybackBuffer->RenderFromJackPorts ( subproc );

  564. 				memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );

  565. 				tx_bytes = Send ( fAudioTxLen, 0 );

  566. 			}

  567. 		}

  568. 		return 0;

  569. 	}

  570. 

  571. //*************************************loader*******************************************************

  572. 

  573. #ifdef __cplusplus

  574. 	extern "C"

  575. 	{

  576. #endif

  577. 		EXPORT jack_driver_desc_t* driver_get_descriptor ()

  578. 		{

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

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

  581. 			desc->nparams = 8;

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

  583. 

  584. 			int i = 0;

  585. 			strcpy ( desc->params[i].name, "multicast_ip" );

  586. 			desc->params[i].character = 'a';

  587. 			desc->params[i].type = JackDriverParamString;

  588. 			strcpy ( desc->params[i].value.str, DEFAULT_MULTICAST_IP );

  589. 			strcpy ( desc->params[i].short_desc, "Multicast Address" );

  590. 			strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  591. 

  592. 			i++;

  593. 			strcpy ( desc->params[i].name, "udp_net_port" );

  594. 			desc->params[i].character = 'p';

  595. 			desc->params[i].type = JackDriverParamInt;

  596. 			desc->params[i].value.i = 19000;

  597. 			strcpy ( desc->params[i].short_desc, "UDP port" );

  598. 			strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  599. 

  600. 			i++;

  601. 			strcpy ( desc->params[i].name, "mtu" );

  602. 			desc->params[i].character = 'M';

  603. 			desc->params[i].type = JackDriverParamInt;

  604. 			desc->params[i].value.i = 1500;

  605. 			strcpy ( desc->params[i].short_desc, "MTU to the master" );

  606. 			strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  607. 

  608. 			i++;

  609. 			strcpy ( desc->params[i].name, "input_ports" );

  610. 			desc->params[i].character = 'C';

  611. 			desc->params[i].type = JackDriverParamInt;

  612. 			desc->params[i].value.i = 2;

  613. 			strcpy ( desc->params[i].short_desc, "Number of audio input ports" );

  614. 			strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  615. 

  616. 			i++;

  617. 			strcpy ( desc->params[i].name, "output_ports" );

  618. 			desc->params[i].character = 'P';

  619. 			desc->params[i].type = JackDriverParamInt;

  620. 			desc->params[i].value.i = 2;

  621. 			strcpy ( desc->params[i].short_desc, "Number of audio output ports" );

  622. 			strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  623. 

  624. 			i++;

  625. 			strcpy ( desc->params[i].name, "midi_in_ports" );

  626. 			desc->params[i].character = 'i';

  627. 			desc->params[i].type = JackDriverParamInt;

  628. 			desc->params[i].value.i = 0;

  629. 			strcpy ( desc->params[i].short_desc, "Number of midi input ports" );

  630. 			strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  631. 

  632. 			i++;

  633. 			strcpy ( desc->params[i].name, "midi_out_ports" );

  634. 			desc->params[i].character = 'o';

  635. 			desc->params[i].type = JackDriverParamUInt;

  636. 			desc->params[i].value.i = 0;

  637. 			strcpy ( desc->params[i].short_desc, "Number of midi output ports" );

  638. 			strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  639. 

  640. 			i++;

  641. 			strcpy ( desc->params[i].name, "client_name" );

  642. 			desc->params[i].character = 'n';

  643. 			desc->params[i].type = JackDriverParamString;

  644. 			strcpy ( desc->params[i].value.str, "'hostname'" );

  645. 			strcpy ( desc->params[i].short_desc, "Name of the jack client" );

  646. 			strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  647. 

  648. 			return desc;

  649. 		}

  650. 

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

  652. 		{

  653. 			const char* multicast_ip = DEFAULT_MULTICAST_IP;

  654. 			char name[JACK_CLIENT_NAME_SIZE];

  655. 			gethostname ( name, JACK_CLIENT_NAME_SIZE );

  656. 			int udp_port = DEFAULT_PORT;

  657. 			int mtu = 1500;

  658. 			jack_nframes_t period_size = 128;

  659. 			jack_nframes_t sample_rate = 48000;

  660. 			int audio_capture_ports = 2;

  661. 			int audio_playback_ports = 2;

  662. 			int midi_input_ports = 0;

  663. 			int midi_output_ports = 0;

  664. 			bool monitor = false;

  665. 

  666. 			const JSList* node;

  667. 			const jack_driver_param_t* param;

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

  669. 			{

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

  671. 				switch ( param->character )

  672. 				{

  673. 					case 'a' :

  674. 						multicast_ip = strdup ( param->value.str );

  675. 						break;

  676. 					case 'p':

  677. 						udp_port = param->value.ui;

  678. 						break;

  679. 					case 'M':

  680. 						mtu = param->value.i;

  681. 						break;

  682. 					case 'C':

  683. 						audio_capture_ports = param->value.i;

  684. 						break;

  685. 					case 'P':

  686. 						audio_playback_ports = param->value.i;

  687. 						break;

  688. 					case 'i':

  689. 						midi_input_ports = param->value.i;

  690. 						break;

  691. 					case 'o':

  692. 						midi_output_ports = param->value.i;

  693. 						break;

  694. 					case 'n' :

  695. 						strncpy ( name, param->value.str, JACK_CLIENT_NAME_SIZE );

  696. 				}

  697. 			}

  698. 

  699. 			Jack::JackDriverClientInterface* driver = new Jack::JackWaitThreadedDriver (

  700. 			    new Jack::JackNetDriver ( "system", "net_pcm", engine, table, multicast_ip, udp_port, mtu, midi_input_ports, midi_output_ports, name ) );

  701. 			if ( driver->Open ( period_size, sample_rate, 1, 1, audio_capture_ports, audio_playback_ports,

  702. 			                    monitor, "from_master_", "to_master_", 0, 0 ) == 0 )

  703. 				return driver;

  704. 

  705. 			delete driver;

  706. 			return NULL;

  707. 		}

  708. 

  709. #ifdef __cplusplus

  710. 	}

  711. #endif

  712. }