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.
976 Commits
7 Branches
223MB
Tree: 542ac90d1e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '542ac90d1e'
${ noResults }
jack2/common/JackNetDriver.cpp

710 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. 		SetBufferSize ( fParams.fPeriodSize );

  259. 		SetSampleRate ( fParams.fSampleRate );

  260. 

  261. 		//allocate midi ports lists

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

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

  264. 

  265. 		//register jack ports

  266. 		if ( AllocPorts() != 0 )

  267. 		{

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

  269. 			return -1;

  270. 		}

  271. 

  272. 		//TX header init

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

  274. 		fTxHeader.fDataStream = 'r';

  275. 		fTxHeader.fID = fParams.fID;

  276. 		fTxHeader.fCycle = 0;

  277. 		fTxHeader.fSubCycle = 0;

  278. 		fTxHeader.fMidiDataSize = 0;

  279. 		fTxHeader.fBitdepth = fParams.fBitdepth;

  280. 

  281. 		//RX header init

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

  283. 		fRxHeader.fDataStream = 's';

  284. 		fRxHeader.fID = fParams.fID;

  285. 		fRxHeader.fCycle = 0;

  286. 		fRxHeader.fSubCycle = 0;

  287. 		fRxHeader.fMidiDataSize = 0;

  288. 		fRxHeader.fBitdepth = fParams.fBitdepth;

  289. 

  290. 		//network buffers

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

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

  293. 

  294. 		//net audio/midi buffers

  295. 		fTxData = fTxBuffer + sizeof ( packet_header_t );

  296. 		fRxData = fRxBuffer + sizeof ( packet_header_t );

  297. 

  298. 		//midi net buffers

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

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

  301. 

  302. 		//audio net buffers

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

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

  305. 

  306. 		//audio netbuffer length

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

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

  309. 

  310. 		return 0;

  311. 	}

  312. 

  313. 	int JackNetDriver::AllocPorts()

  314. 	{

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

  316. 		JackPort* port;

  317. 		jack_port_id_t port_id;

  318. 		char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  319. 		char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  320. 		unsigned long port_flags;

  321. 

  322. 		//audio

  323. 		port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  325. 		{

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

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

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

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

  330. 			{

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

  332. 				return -1;

  333. 			}

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

  335. 			port->SetAlias ( alias );

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

  337. 			fCapturePortList[port_index] = port_id;

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

  339. 		}

  340. 		port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  342. 		{

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

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

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

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

  347. 			{

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

  349. 				return -1;

  350. 			}

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

  352. 			port->SetAlias ( alias );

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

  354. 			fPlaybackPortList[port_index] = port_id;

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

  356. 		}

  357. 		//midi

  358. 		port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  360. 		{

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

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

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

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

  365. 			{

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

  367. 				return -1;

  368. 			}

  369. 			fMidiCapturePortList[port_index] = port_id;

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

  371. 		}

  372. 

  373. 		port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  375. 		{

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

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

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

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

  380. 			{

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

  382. 				return -1;

  383. 			}

  384. 			fMidiPlaybackPortList[port_index] = port_id;

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

  386. 		}

  387. 

  388. 		return 0;

  389. 	}

  390. 

  391. 	int JackNetDriver::FreePorts()

  392. 	{

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

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

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

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

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

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

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

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

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

  402. 		return 0;

  403. 	}

  404. 

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

  406. 	{

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

  408. 	}

  409. 

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

  411. 	{

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

  413. 	}

  414. 

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

  416. 	{

  417. 		int rx_bytes;

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

  419. 		{

  420. 			if ( errno == EAGAIN )

  421. 			{

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

  423. 				return 0;

  424. 			}

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

  426. 			{

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

  428. 				throw JackDriverException();

  429. 			}

  430. 			else

  431. 			{

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

  433. 				return 0;

  434. 			}

  435. 		}

  436. 		return rx_bytes;

  437. 	}

  438. 

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

  440. 	{

  441. 		int tx_bytes;

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

  443. 		{

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

  445. 			{

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

  447. 				throw JackDriverException();

  448. 			}

  449. 			else

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

  451. 		}

  452. 		return tx_bytes;

  453. 	}

  454. 

  455. //*************************************process************************************************************************

  456. 

  457. 	int JackNetDriver::Read()

  458. 	{

  459. 		int rx_bytes;

  460. 		uint recvd_midi_pckt = 0;

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

  462. 		fRxHeader.fIsLastPckt = 'n';

  463. 

  464. 		//buffers

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

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

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

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

  469. 

  470. 		//receive sync (launch the cycle)

  471. 		do

  472. 		{

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

  474. 				return rx_bytes;

  475. 		}

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

  477. 

  478. 		JackDriver::CycleTakeBeginTime();

  479. 

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

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

  482. 		{

  483. 			do

  484. 			{

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

  486. 				if ( rx_bytes < 1 )

  487. 					return rx_bytes;

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

  489. 				{

  490. 					switch ( rx_head->fDataType )

  491. 					{

  492. 						case 'm':	//midi

  493. 							rx_bytes = Recv ( rx_bytes, MSG_DONTWAIT );

  494. 							fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

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

  497. 								fNetMidiCaptureBuffer->RenderToJackPorts();

  498. 							break;

  499. 						case 'a':	//audio

  500. 							rx_bytes = Recv ( fAudioRxLen, MSG_DONTWAIT );

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

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

  503. 							fRxHeader.fCycle = rx_head->fCycle;

  504. 							fRxHeader.fSubCycle = rx_head->fSubCycle;

  505. 							fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

  507. 							break;

  508. 						case 's':	//sync

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

  510. 							fRxHeader.fCycle = rx_head->fCycle;

  511. 							return 0;

  512. 					}

  513. 				}

  514. 			}

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

  516. 		}

  517. 		fRxHeader.fCycle = rx_head->fCycle;

  518. 		return 0;

  519. 	}

  520. 

  521. 	int JackNetDriver::Write()

  522. 	{

  523. 		int tx_bytes, copy_size;

  524. 		fTxHeader.fCycle = fRxHeader.fCycle;

  525. 		fTxHeader.fSubCycle = 0;

  526. 		fTxHeader.fIsLastPckt = 'n';

  527. 

  528. 		//buffers

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

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

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

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

  533. 

  534. 		//midi

  535. 		if ( fParams.fReturnMidiChannels )

  536. 		{

  537. 			fTxHeader.fDataType = 'm';

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

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

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

  541. 			{

  542. 				fTxHeader.fSubCycle = subproc;

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

  544. 					fTxHeader.fIsLastPckt = 'y';

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

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

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

  548. 			}

  549. 		}

  550. 

  551. 		//audio

  552. 		if ( fParams.fReturnAudioChannels )

  553. 		{

  554. 			fTxHeader.fDataType = 'a';

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

  556. 			{

  557. 				fTxHeader.fSubCycle = subproc;

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

  559. 					fTxHeader.fIsLastPckt = 'y';

  560. 				fNetAudioPlaybackBuffer->RenderFromJackPorts ( subproc );

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

  562. 				tx_bytes = Send ( fAudioTxLen, 0 );

  563. 			}

  564. 		}

  565. 		return 0;

  566. 	}

  567. 

  568. //*************************************loader*******************************************************

  569. 

  570. #ifdef __cplusplus

  571. 	extern "C"

  572. 	{

  573. #endif

  574. 		EXPORT jack_driver_desc_t* driver_get_descriptor ()

  575. 		{

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

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

  578. 			desc->nparams = 8;

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

  580. 

  581. 			int i = 0;

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

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

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

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

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

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

  588. 

  589. 			i++;

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

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

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

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

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

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

  596. 

  597. 			i++;

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

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

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

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

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

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

  604. 

  605. 			i++;

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

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

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

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

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

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

  612. 

  613. 			i++;

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

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

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

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

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

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

  620. 

  621. 			i++;

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

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

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

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

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

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

  628. 

  629. 			i++;

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

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

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

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

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

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

  636. 

  637. 			i++;

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

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

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

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

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

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

  644. 

  645. 			return desc;

  646. 		}

  647. 

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

  649. 		{

  650. 			const char* multicast_ip = DEFAULT_MULTICAST_IP;

  651. 			char name[JACK_CLIENT_NAME_SIZE];

  652. 			gethostname ( name, JACK_CLIENT_NAME_SIZE );

  653. 			int udp_port = DEFAULT_PORT;

  654. 			int mtu = 1500;

  655. 			jack_nframes_t period_size = 128;

  656. 			jack_nframes_t sample_rate = 48000;

  657. 			int audio_capture_ports = 2;

  658. 			int audio_playback_ports = 2;

  659. 			int midi_input_ports = 0;

  660. 			int midi_output_ports = 0;

  661. 			bool monitor = false;

  662. 

  663. 			const JSList* node;

  664. 			const jack_driver_param_t* param;

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

  666. 			{

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

  668. 				switch ( param->character )

  669. 				{

  670. 					case 'a' :

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

  672. 						break;

  673. 					case 'p':

  674. 						udp_port = param->value.ui;

  675. 						break;

  676. 					case 'M':

  677. 						mtu = param->value.i;

  678. 						break;

  679. 					case 'C':

  680. 						audio_capture_ports = param->value.i;

  681. 						break;

  682. 					case 'P':

  683. 						audio_playback_ports = param->value.i;

  684. 						break;

  685. 					case 'i':

  686. 						midi_input_ports = param->value.i;

  687. 						break;

  688. 					case 'o':

  689. 						midi_output_ports = param->value.i;

  690. 						break;

  691. 					case 'n' :

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

  693. 				}

  694. 			}

  695. 

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

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

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

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

  700. 				return driver;

  701. 

  702. 			delete driver;

  703. 			return NULL;

  704. 		}

  705. 

  706. #ifdef __cplusplus

  707. 	}

  708. #endif

  709. }