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

705 lines
24KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2001 Paul Davis

  3. Copyright (C) 2004-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, size_t port, 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. 		fPort = port;

  44. 		fParams.fSendMidiChannels = midi_input_ports;

  45. 		fParams.fReturnMidiChannels = midi_output_ports;

  46. 		strcpy ( fParams.fName, net_name );

  47. 		fSockfd = 0;

  48. 	}

  49. 

  50. 	JackNetDriver::~JackNetDriver()

  51. 	{

  52. 		if ( fSockfd )

  53. 			close ( fSockfd );

  54. 		delete fNetAudioCaptureBuffer;

  55. 		delete fNetAudioPlaybackBuffer;

  56. 		delete fNetMidiCaptureBuffer;

  57. 		delete fNetMidiPlaybackBuffer;

  58. 		delete[] fTxBuffer;

  59. 		delete[] fRxBuffer;

  60. 		delete[] fMulticastIP;

  61. 		delete[] fMidiCapturePortList;

  62. 		delete[] fMidiPlaybackPortList;

  63. 	}

  64. 

  65. //*************************************initialization***********************************************************************

  66. 

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

  68. 	                          int inchannels, int outchannels, bool monitor,

  69. 	                          const char* capture_driver_name, const char* playback_driver_name,

  70. 	                          jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  71. 	{

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

  73. 		                                  capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  74. 		fEngineControl->fPeriod = 0;

  75. 		fEngineControl->fComputation = 500 * 1000;

  76. 		fEngineControl->fConstraint = 500 * 1000;

  77. 		return res;

  78. 	}

  79. 

  80. 	int JackNetDriver::Attach()

  81. 	{

  82. 		return 0;

  83. 	}

  84. 

  85. 	int JackNetDriver::Detach()

  86. 	{

  87. 		return 0;

  88. 	}

  89.     

  90.     int JackNetDriver::ProcessNull()

  91.     {

  92.         JackDriver::CycleTakeTime();

  93.         int wait_time = (int((float(fEngineControl->fBufferSize) / (float(fEngineControl->fSampleRate))) * 1000000.0f));

  94.         usleep(wait_time);

  95.         return JackAudioDriver::ProcessNull();

  96.     }

  97. 

  98. 	bool JackNetDriver::Init()

  99. 	{

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

  101. 		if ( fSockfd )

  102. 			Restart();

  103. 

  104. 		//set the parameters to send

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

  106. 		fParams.fProtocolVersion = 'a';

  107. 		SetPacketType ( &fParams, SLAVE_AVAILABLE );

  108. 		gethostname ( fParams.fSlaveNetName, 255 );

  109. 		fParams.fSendAudioChannels = fCaptureChannels;

  110. 		fParams.fReturnAudioChannels = fPlaybackChannels;

  111. 

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

  113. 		net_status_t status;

  114. 		do

  115. 		{

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

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

  118. 			do

  119. 			{

  120. 				status = GetNetMaster();

  121. 				if ( status == SOCKET_ERROR )

  122. 					return false;

  123. 			}

  124. 			while ( status != CONNECTED );

  125. 

  126. 			//then tell the master we are ready

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

  128. 			status = SendMasterStartSync();

  129. 			if ( status == NET_ERROR )

  130. 				return false;

  131. 		}

  132. 		while ( status != ROLLING );

  133. 

  134. 		//driver parametering

  135. 		if ( SetParams() )

  136. 		{

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

  138. 			return false;

  139. 		}

  140. 

  141. 		//init done, display parameters

  142. 		SessionParamsDisplay ( &fParams );

  143. 

  144. 		return true;

  145. 	}

  146. 

  147. 	net_status_t JackNetDriver::GetNetMaster()

  148. 	{

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

  150. 		//utility

  151. 		session_params_t params;

  152. 		struct sockaddr_in mcast_addr, listen_addr;

  153. 		struct timeval rcv_timeout;

  154. 		rcv_timeout.tv_sec = 2;

  155. 		rcv_timeout.tv_usec = 0;

  156. 		socklen_t addr_len = sizeof ( socket_address_t );

  157. 		int rx_bytes = 0;

  158. 

  159. 		//set the multicast address

  160. 		mcast_addr.sin_family = AF_INET;

  161. 		mcast_addr.sin_port = htons ( fPort );

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

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

  164. 

  165. 		//set the listening address

  166. 		listen_addr.sin_family = AF_INET;

  167. 		listen_addr.sin_port = htons ( fPort );

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

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

  170. 

  171. 		//set the master address family

  172. 		fMasterAddr.sin_family = AF_INET;

  173. 

  174. 		//socket

  175. 		if ( fSockfd )

  176. 			close ( fSockfd );

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

  178. 		{

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

  180. 			return SOCKET_ERROR;

  181. 		}

  182. 

  183. 		//bind the socket

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

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

  186. 

  187. 		//timeout on receive

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

  189. 

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

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

  192. 		do

  193. 		{

  194. 			//send 'available'

  195. 			if ( sendto ( fSockfd, &fParams, sizeof ( session_params_t ), MSG_DONTWAIT,

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

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

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

  199. 			do

  200. 			{

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

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

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

  204. 				{

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

  206. 					return RECV_ERROR;

  207. 				}

  208. 			}

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

  210. 		}

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

  212. 

  213. 		//connect the socket

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

  215. 		{

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

  217. 			return CONNECT_ERROR;

  218. 		}

  219. 

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

  221. 		fParams = params;

  222. 

  223. 		return CONNECTED;

  224. 	}

  225. 

  226. 	net_status_t JackNetDriver::SendMasterStartSync()

  227. 	{

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

  229. 		//tell the master to start

  230. 		SetPacketType ( &fParams, START_MASTER );

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

  232. 		{

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

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

  235. 		}

  236. 		return ROLLING;

  237. 	}

  238. 

  239. 	void JackNetDriver::Restart()

  240. 	{

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

  242. 		close ( fSockfd );

  243. 		delete[] fTxBuffer;

  244. 		delete[] fRxBuffer;

  245. 		delete fNetAudioCaptureBuffer;

  246. 		delete fNetAudioPlaybackBuffer;

  247. 		delete fNetMidiCaptureBuffer;

  248. 		delete fNetMidiPlaybackBuffer;

  249. 		FreePorts();

  250. 		delete[] fMidiCapturePortList;

  251. 		delete[] fMidiPlaybackPortList;

  252. 		fTxBuffer = NULL;

  253. 		fRxBuffer = NULL;

  254. 		fNetAudioCaptureBuffer = NULL;

  255. 		fNetAudioPlaybackBuffer = NULL;

  256. 		fNetMidiCaptureBuffer = NULL;

  257. 		fNetMidiPlaybackBuffer = NULL;

  258. 		fMidiCapturePortList = NULL;

  259. 		fMidiPlaybackPortList = NULL;

  260. 	}

  261. 

  262. 	int JackNetDriver::SetParams()

  263. 	{

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

  265. 		SetBufferSize ( fParams.fPeriodSize );

  266. 		SetSampleRate ( fParams.fSampleRate );

  267. 

  268. 		//allocate midi ports lists

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

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

  271. 

  272. 		//register jack ports

  273. 		if ( AllocPorts() != 0 )

  274. 		{

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

  276. 			return -1;

  277. 		}

  278. 

  279. 		//TX header init

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

  281. 		fTxHeader.fDataStream = 'r';

  282. 		fTxHeader.fID = fParams.fID;

  283. 		fTxHeader.fCycle = 0;

  284. 		fTxHeader.fSubCycle = 0;

  285. 		fTxHeader.fMidiDataSize = 0;

  286. 		fTxHeader.fBitdepth = fParams.fBitdepth;

  287. 

  288. 		//RX header init

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

  290. 		fRxHeader.fDataStream = 's';

  291. 		fRxHeader.fID = fParams.fID;

  292. 		fRxHeader.fCycle = 0;

  293. 		fRxHeader.fSubCycle = 0;

  294. 		fRxHeader.fMidiDataSize = 0;

  295. 		fRxHeader.fBitdepth = fParams.fBitdepth;

  296. 

  297. 		//network buffers

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

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

  300. 

  301. 		//net audio/midi buffers

  302. 		fTxData = fTxBuffer + sizeof ( packet_header_t );

  303. 		fRxData = fRxBuffer + sizeof ( packet_header_t );

  304. 

  305. 		//midi net buffers

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

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

  308. 

  309. 		//audio net buffers

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

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

  312. 

  313. 		//audio netbuffer length

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

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

  316. 

  317. 		return 0;

  318. 	}

  319. 

  320. 	int JackNetDriver::AllocPorts()

  321. 	{

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

  323. 		JackPort* port;

  324. 		jack_port_id_t port_id;

  325. 		char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  326. 		char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  327. 		unsigned long port_flags;

  328. 

  329. 		//audio

  330. 		port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  332. 		{

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

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

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

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

  337. 			{

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

  339. 				return -1;

  340. 			}

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

  342. 			port->SetAlias ( alias );

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

  344. 			fCapturePortList[port_index] = port_id;

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

  346. 		}

  347. 		port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  349. 		{

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

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

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

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

  354. 			{

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

  356. 				return -1;

  357. 			}

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

  359. 			port->SetAlias ( alias );

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

  361. 			fPlaybackPortList[port_index] = port_id;

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

  363. 		}

  364. 		//midi

  365. 		port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  366. 		for ( int port_index = 0; port_index < fParams.fSendMidiChannels; port_index++ )

  367. 		{

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

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

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

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

  372. 			{

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

  374. 				return -1;

  375. 			}

  376. 			fMidiCapturePortList[port_index] = port_id;

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

  378. 		}

  379. 

  380. 		port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  381. 		for ( int port_index = 0; port_index < fParams.fReturnMidiChannels; port_index++ )

  382. 		{

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

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

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

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

  387. 			{

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

  389. 				return -1;

  390. 			}

  391. 			fMidiPlaybackPortList[port_index] = port_id;

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

  393. 		}

  394. 

  395. 		return 0;

  396. 	}

  397. 

  398. 	int JackNetDriver::FreePorts()

  399. 	{

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

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

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

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

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

  405. 		for ( int port_index = 0; port_index < fParams.fSendMidiChannels; port_index++ )

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

  407. 		for ( int port_index = 0; port_index < fParams.fReturnMidiChannels; port_index++ )

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

  409. 		return 0;

  410. 	}

  411. 

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

  413. 	{

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

  415. 	}

  416. 

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

  418. 	{

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

  420. 	}

  421. 

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

  423. 	{

  424. 		int rx_bytes;

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

  426. 		{

  427. 			if ( errno == EAGAIN )

  428. 			{

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

  430. 				return 0;

  431. 			}

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

  433. 			{

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

  435. 				throw JackDriverException();

  436. 			}

  437. 			else

  438. 			{

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

  440. 				return 0;

  441. 			}

  442. 		}

  443. 		return rx_bytes;

  444. 	}

  445. 

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

  447. 	{

  448. 		int tx_bytes;

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

  450. 		{

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

  452. 			{

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

  454. 				throw JackDriverException();

  455. 			}

  456. 			else

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

  458. 		}

  459. 		return tx_bytes;

  460. 	}

  461. 

  462. //*************************************process************************************************************************

  463. 

  464. 	int JackNetDriver::Read()

  465. 	{

  466. 		int rx_bytes;

  467. 		size_t recvd_midi_pckt = 0;

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

  469. 		fRxHeader.fIsLastPckt = 'n';

  470. 

  471. 		//buffers

  472. 		for ( int port_index = 0; port_index < fParams.fSendMidiChannels; port_index++ )

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

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

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

  476. 

  477. 		//receive sync (launch the cycle)

  478. 		do

  479. 		{

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

  481. 				return rx_bytes;

  482. 		}

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

  484. 

  485. 		JackDriver::CycleTakeTime();

  486. 

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

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

  489. 		{

  490. 			do

  491. 			{

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

  493. 				if ( rx_bytes < 1 )

  494. 					return rx_bytes;

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

  496. 				{

  497. 					switch ( rx_head->fDataType )

  498. 					{

  499. 						case 'm':	//midi

  500. 							rx_bytes = Recv ( rx_bytes, MSG_DONTWAIT );

  501. 							fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

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

  504. 								fNetMidiCaptureBuffer->RenderToJackPorts();

  505. 							break;

  506. 						case 'a':	//audio

  507. 							rx_bytes = Recv ( fAudioRxLen, MSG_DONTWAIT );

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

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

  510. 							fRxHeader.fCycle = rx_head->fCycle;

  511. 							fRxHeader.fSubCycle = rx_head->fSubCycle;

  512. 							fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

  514. 							break;

  515. 						case 's':	//sync

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

  517. 							fRxHeader.fCycle = rx_head->fCycle;

  518. 							return 0;

  519. 					}

  520. 				}

  521. 			}

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

  523. 		}

  524. 		fRxHeader.fCycle = rx_head->fCycle;

  525. 		return 0;

  526. 	}

  527. 

  528. 	int JackNetDriver::Write()

  529. 	{

  530. 		int tx_bytes, copy_size;

  531. 		fTxHeader.fCycle = fRxHeader.fCycle;

  532. 		fTxHeader.fSubCycle = 0;

  533. 		fTxHeader.fIsLastPckt = 'n';

  534. 

  535. 		//buffers

  536. 		for ( int port_index = 0; port_index < fParams.fReturnMidiChannels; port_index++ )

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

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

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

  540. 

  541. 		//midi

  542. 		if ( fParams.fReturnMidiChannels )

  543. 		{

  544. 			fTxHeader.fDataType = 'm';

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

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

  547. 			for ( size_t subproc = 0; subproc < fTxHeader.fNMidiPckt; subproc++ )

  548. 			{

  549. 				fTxHeader.fSubCycle = subproc;

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

  551. 					fTxHeader.fIsLastPckt = 'y';

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

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

  554. 				tx_bytes = Send ( sizeof ( packet_header_t ) + copy_size, MSG_DONTWAIT );

  555. 			}

  556. 		}

  557. 

  558. 		//audio

  559. 		if ( fParams.fReturnAudioChannels )

  560. 		{

  561. 			fTxHeader.fDataType = 'a';

  562. 			for ( size_t subproc = 0; subproc < fNSubProcess; subproc++ )

  563. 			{

  564. 				fTxHeader.fSubCycle = subproc;

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

  566. 					fTxHeader.fIsLastPckt = 'y';

  567. 				fNetAudioPlaybackBuffer->RenderFromJackPorts ( subproc );

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

  569. 				tx_bytes = Send ( fAudioTxLen, MSG_DONTWAIT );

  570. 			}

  571. 		}

  572. 		return 0;

  573. 	}

  574. 

  575. //*************************************loader*******************************************************

  576. 

  577. #ifdef __cplusplus

  578. 	extern "C"

  579. 	{

  580. #endif

  581. 		EXPORT jack_driver_desc_t* driver_get_descriptor ()

  582. 		{

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

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

  585. 			desc->nparams = 7;

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

  587. 

  588. 			size_t i = 0;

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

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

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

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

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

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

  595. 

  596. 			i++;

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

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

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

  600. 			desc->params[i].value.ui = 19000U;

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

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

  603. 

  604. 			i++;

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

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

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

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

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

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

  611. 

  612. 			i++;

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

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

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

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

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

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

  619. 

  620. 			i++;

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

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

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

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

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

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

  627. 

  628. 			i++;

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

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

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

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

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

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

  635. 

  636. 			i++;

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

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

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

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

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

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

  643. 

  644. 			return desc;

  645. 		}

  646. 

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

  648. 		{

  649. 			const char* multicast_ip = DEFAULT_MULTICAST_IP;

  650. 			char name[JACK_CLIENT_NAME_SIZE];

  651. 			gethostname ( name, JACK_CLIENT_NAME_SIZE );

  652. 			jack_nframes_t udp_port = DEFAULT_PORT;

  653. 			jack_nframes_t period_size = 128;

  654. 			jack_nframes_t sample_rate = 48000;

  655. 			int audio_capture_ports = 2;

  656. 			int audio_playback_ports = 2;

  657. 			int midi_input_ports = 0;

  658. 			int midi_output_ports = 0;

  659. 			bool monitor = false;

  660. 

  661. 			const JSList* node;

  662. 			const jack_driver_param_t* param;

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

  664. 			{

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

  666. 				switch ( param->character )

  667. 				{

  668. 					case 'a' :

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

  670. 						break;

  671. 					case 'p':

  672. 						udp_port = param->value.ui;

  673. 						break;

  674. 					case 'C':

  675. 						audio_capture_ports = param->value.i;

  676. 						break;

  677. 					case 'P':

  678. 						audio_playback_ports = param->value.i;

  679. 						break;

  680. 					case 'i':

  681. 						midi_input_ports = param->value.i;

  682. 						break;

  683. 					case 'o':

  684. 						midi_output_ports = param->value.i;

  685. 						break;

  686. 					case 'n' :

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

  688. 				}

  689. 			}

  690.        

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

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

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

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

  695. 				return driver;

  696. 

  697. 			delete driver;

  698. 			return NULL;

  699. 		}

  700. 

  701. #ifdef __cplusplus

  702. 	}

  703. #endif

  704. }