2 Copyright (C) 2001 Paul Davis
3 Copyright (C) 2008 Romain Moret at Grame
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.
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.
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.
20 #include "JackNetInterface.h"
21 #include "JackException.h"
22 #include "JackPlatformPlug.h"
28 TODO : since midi buffers now uses up to BUFFER_SIZE_MAX frames,
29 probably also use BUFFER_SIZE_MAX in everything related to MIDI events
30 handling (see MidiBufferInit in JackMidiPort.cpp)
35 // JackNetInterface*******************************************
37 JackNetInterface::JackNetInterface() : fSocket()
41 fNetAudioCaptureBuffer
= NULL
;
42 fNetAudioPlaybackBuffer
= NULL
;
43 fNetMidiCaptureBuffer
= NULL
;
44 fNetMidiPlaybackBuffer
= NULL
;
45 memset(&fSendTransportData
, 0, sizeof(net_transport_data_t
));
46 memset(&fReturnTransportData
, 0, sizeof(net_transport_data_t
));
49 JackNetInterface::JackNetInterface ( const char* multicast_ip
, int port
) : fSocket ( multicast_ip
, port
)
51 strcpy(fMulticastIP
, multicast_ip
);
54 fNetAudioCaptureBuffer
= NULL
;
55 fNetAudioPlaybackBuffer
= NULL
;
56 fNetMidiCaptureBuffer
= NULL
;
57 fNetMidiPlaybackBuffer
= NULL
;
58 memset(&fSendTransportData
, 0, sizeof(net_transport_data_t
));
59 memset(&fReturnTransportData
, 0, sizeof(net_transport_data_t
));
62 JackNetInterface::JackNetInterface ( session_params_t
& params
, JackNetSocket
& socket
, const char* multicast_ip
) : fSocket ( socket
)
65 strcpy(fMulticastIP
, multicast_ip
);
68 fNetAudioCaptureBuffer
= NULL
;
69 fNetAudioPlaybackBuffer
= NULL
;
70 fNetMidiCaptureBuffer
= NULL
;
71 fNetMidiPlaybackBuffer
= NULL
;
72 memset(&fSendTransportData
, 0, sizeof(net_transport_data_t
));
73 memset(&fReturnTransportData
, 0, sizeof(net_transport_data_t
));
76 JackNetInterface::~JackNetInterface()
78 jack_log ( "JackNetInterface::~JackNetInterface" );
83 delete fNetAudioCaptureBuffer
;
84 delete fNetAudioPlaybackBuffer
;
85 delete fNetMidiCaptureBuffer
;
86 delete fNetMidiPlaybackBuffer
;
89 void JackNetInterface::SetFramesPerPacket()
91 jack_log ( "JackNetInterface::SetFramesPerPacket" );
93 if (fParams
.fSendAudioChannels
== 0 && fParams
.fReturnAudioChannels
== 0) {
94 fParams
.fFramesPerPacket
= fParams
.fPeriodSize
;
96 jack_nframes_t period
= ( int ) powf ( 2.f
, ( int ) ( log (float ( fParams
.fMtu
- sizeof ( packet_header_t
) )
97 / ( max ( fParams
.fReturnAudioChannels
, fParams
.fSendAudioChannels
) * sizeof ( sample_t
) ) ) / log ( 2. ) ) );
98 fParams
.fFramesPerPacket
= ( period
> fParams
.fPeriodSize
) ? fParams
.fPeriodSize
: period
;
102 int JackNetInterface::SetNetBufferSize()
104 jack_log ( "JackNetInterface::SetNetBufferSize" );
106 float audio_size
, midi_size
;
109 audio_size
= fParams
.fMtu
* ( fParams
.fPeriodSize
/ fParams
.fFramesPerPacket
);
111 midi_size
= fParams
.fMtu
* ( max ( fParams
.fSendMidiChannels
, fParams
.fReturnMidiChannels
) *
112 fParams
.fPeriodSize
* sizeof ( sample_t
) / ( fParams
.fMtu
- sizeof ( packet_header_t
) ) );
113 //bufsize = sync + audio + midi
114 bufsize
= MAX_LATENCY
* (fParams
.fMtu
+ ( int ) audio_size
+ ( int ) midi_size
);
117 if ( fSocket
.SetOption ( SOL_SOCKET
, SO_SNDBUF
, &bufsize
, sizeof ( bufsize
) ) == SOCKET_ERROR
)
121 if ( fSocket
.SetOption ( SOL_SOCKET
, SO_RCVBUF
, &bufsize
, sizeof ( bufsize
) ) == SOCKET_ERROR
)
127 int JackNetInterface::GetNMidiPckt()
129 //even if there is no midi data, jack need an empty buffer to know there is no event to read
130 //99% of the cases : all data in one packet
131 if ( fTxHeader
.fMidiDataSize
<= ( fParams
.fMtu
- sizeof ( packet_header_t
) ) )
133 //else, get the number of needed packets (simply slice the biiig buffer)
134 int npckt
= fTxHeader
.fMidiDataSize
/ ( fParams
.fMtu
- sizeof ( packet_header_t
) );
135 if ( fTxHeader
.fMidiDataSize
% ( fParams
.fMtu
- sizeof ( packet_header_t
) ) )
140 bool JackNetInterface::IsNextPacket()
142 packet_header_t
* rx_head
= reinterpret_cast<packet_header_t
*> ( fRxBuffer
);
144 if ( fRxHeader
.fCycle
<= 1 ) {
147 //same PcktID (cycle), next SubPcktID (subcycle)
148 if ( ( fRxHeader
.fSubCycle
< ( fNSubProcess
- 1 ) ) && ( rx_head
->fCycle
== fRxHeader
.fCycle
) && ( rx_head
->fSubCycle
== ( fRxHeader
.fSubCycle
+ 1 ) ) ) {
151 //next PcktID (cycle), SubPcktID reset to 0 (first subcyle)
152 if ( ( rx_head
->fCycle
== ( fRxHeader
.fCycle
+ 1 ) ) && ( fRxHeader
.fSubCycle
== ( fNSubProcess
- 1 ) ) && ( rx_head
->fSubCycle
== 0 ) ) {
155 //else, packet(s) missing, return false
159 void JackNetInterface::SetParams()
161 //number of audio subcycles (packets)
162 fNSubProcess
= fParams
.fPeriodSize
/ fParams
.fFramesPerPacket
;
165 fPayloadSize
= fParams
.fMtu
- sizeof ( packet_header_t
);
168 strcpy ( fTxHeader
.fPacketType
, "header" );
169 fTxHeader
.fID
= fParams
.fID
;
170 fTxHeader
.fCycle
= 0;
171 fTxHeader
.fSubCycle
= 0;
172 fTxHeader
.fMidiDataSize
= 0;
173 fTxHeader
.fBitdepth
= fParams
.fBitdepth
;
174 fTxHeader
.fIsLastPckt
= 0;
177 strcpy ( fRxHeader
.fPacketType
, "header" );
178 fRxHeader
.fID
= fParams
.fID
;
179 fRxHeader
.fCycle
= 0;
180 fRxHeader
.fSubCycle
= 0;
181 fRxHeader
.fMidiDataSize
= 0;
182 fRxHeader
.fBitdepth
= fParams
.fBitdepth
;
183 fRxHeader
.fIsLastPckt
= 0;
186 fTxBuffer
= new char[fParams
.fMtu
];
187 fRxBuffer
= new char[fParams
.fMtu
];
188 assert ( fTxBuffer
);
189 assert ( fRxBuffer
);
191 //net audio/midi buffers'addresses
192 fTxData
= fTxBuffer
+ sizeof ( packet_header_t
);
193 fRxData
= fRxBuffer
+ sizeof ( packet_header_t
);
196 // JackNetMasterInterface ************************************************************************************
198 bool JackNetMasterInterface::Init()
200 jack_log ( "JackNetMasterInterface::Init, ID %u.", fParams
.fID
);
202 session_params_t host_params
;
207 if ( fSocket
.NewSocket() == SOCKET_ERROR
) {
208 jack_error ( "Can't create socket : %s", StrError ( NET_ERROR_CODE
) );
212 //timeout on receive (for init)
213 if ( fSocket
.SetTimeOut ( MASTER_INIT_TIMEOUT
) < 0 )
214 jack_error ( "Can't set timeout : %s", StrError ( NET_ERROR_CODE
) );
217 if ( fSocket
.Connect() == SOCKET_ERROR
) {
218 jack_error ( "Can't connect : %s", StrError ( NET_ERROR_CODE
) );
222 //set the number of complete audio frames we can put in a packet
223 SetFramesPerPacket();
225 //send 'SLAVE_SETUP' until 'START_MASTER' received
226 jack_info ( "Sending parameters to %s ...", fParams
.fSlaveNetName
);
229 session_params_t net_params
;
230 memset(&net_params
, 0, sizeof ( session_params_t
));
231 SetPacketType ( &fParams
, SLAVE_SETUP
);
232 SessionParamsHToN(&fParams
, &net_params
);
234 if ( fSocket
.Send ( &net_params
, sizeof ( session_params_t
), 0 ) == SOCKET_ERROR
)
235 jack_error ( "Error in send : ", StrError ( NET_ERROR_CODE
) );
237 memset(&net_params
, 0, sizeof ( session_params_t
));
238 if ( ( ( rx_bytes
= fSocket
.Recv ( &net_params
, sizeof ( session_params_t
), 0 ) ) == SOCKET_ERROR
) && ( fSocket
.GetError() != NET_NO_DATA
) )
240 jack_error ( "Problem with network." );
244 SessionParamsNToH(&net_params
, &host_params
);
246 while ( ( GetPacketType ( &host_params
) != START_MASTER
) && ( ++attempt
< SLAVE_SETUP_RETRY
) );
247 if ( attempt
== SLAVE_SETUP_RETRY
) {
248 jack_error ( "Slave doesn't respond, exiting." );
252 //set the new timeout for the socket
253 if ( SetRxTimeout() == SOCKET_ERROR
) {
254 jack_error ( "Can't set rx timeout : %s", StrError ( NET_ERROR_CODE
) );
258 //set the new rx buffer size
259 if ( SetNetBufferSize() == SOCKET_ERROR
) {
260 jack_error ( "Can't set net buffer sizes : %s", StrError ( NET_ERROR_CODE
) );
267 int JackNetMasterInterface::SetRxTimeout()
269 jack_log ( "JackNetMasterInterface::SetRxTimeout" );
272 //slow or normal mode, short timeout on recv (2 audio subcycles)
273 if ( ( fParams
.fNetworkMode
== 's' ) || ( fParams
.fNetworkMode
== 'n' ) )
274 time
= 2000000.f
* ( static_cast<float> ( fParams
.fFramesPerPacket
) / static_cast<float> ( fParams
.fSampleRate
) );
275 //fast mode, wait for 75% of the entire cycle duration
276 else if ( fParams
.fNetworkMode
== 'f' )
277 time
= 750000.f
* ( static_cast<float> ( fParams
.fPeriodSize
) / static_cast<float> ( fParams
.fSampleRate
) );
278 return fSocket
.SetTimeOut ( static_cast<int> ( time
) );
281 void JackNetMasterInterface::SetParams()
283 jack_log ( "JackNetMasterInterface::SetParams" );
285 JackNetInterface::SetParams();
287 fTxHeader
.fDataStream
= 's';
288 fRxHeader
.fDataStream
= 'r';
291 fNetMidiCaptureBuffer
= new NetMidiBuffer ( &fParams
, fParams
.fSendMidiChannels
, fTxData
);
292 fNetMidiPlaybackBuffer
= new NetMidiBuffer ( &fParams
, fParams
.fReturnMidiChannels
, fRxData
);
293 assert ( fNetMidiCaptureBuffer
);
294 assert ( fNetMidiPlaybackBuffer
);
297 fNetAudioCaptureBuffer
= new NetAudioBuffer ( &fParams
, fParams
.fSendAudioChannels
, fTxData
);
298 fNetAudioPlaybackBuffer
= new NetAudioBuffer ( &fParams
, fParams
.fReturnAudioChannels
, fRxData
);
299 assert ( fNetAudioCaptureBuffer
);
300 assert ( fNetAudioPlaybackBuffer
);
302 //audio netbuffer length
303 fAudioTxLen
= sizeof ( packet_header_t
) + fNetAudioCaptureBuffer
->GetSize();
304 fAudioRxLen
= sizeof ( packet_header_t
) + fNetAudioPlaybackBuffer
->GetSize();
307 void JackNetMasterInterface::Exit()
309 jack_log ( "JackNetMasterInterface::Exit, ID %u", fParams
.fID
);
314 //send a 'multicast euthanasia request' - new socket is required on macosx
315 jack_info ( "Exiting '%s'", fParams
.fName
);
316 SetPacketType ( &fParams
, KILL_MASTER
);
317 JackNetSocket
mcast_socket ( fMulticastIP
, fSocket
.GetPort() );
319 session_params_t net_params
;
320 memset(&net_params
, 0, sizeof ( session_params_t
));
321 SessionParamsHToN(&fParams
, &net_params
);
323 if ( mcast_socket
.NewSocket() == SOCKET_ERROR
)
324 jack_error ( "Can't create socket : %s", StrError ( NET_ERROR_CODE
) );
325 if ( mcast_socket
.SendTo ( &net_params
, sizeof ( session_params_t
), 0, fMulticastIP
) == SOCKET_ERROR
)
326 jack_error ( "Can't send suicide request : %s", StrError ( NET_ERROR_CODE
) );
328 mcast_socket
.Close();
331 int JackNetMasterInterface::Recv ( size_t size
, int flags
)
334 if ( ( ( rx_bytes
= fSocket
.Recv ( fRxBuffer
, size
, flags
) ) == SOCKET_ERROR
) && fRunning
)
336 net_error_t error
= fSocket
.GetError();
337 //no data isn't really a network error, so just return 0 avalaible read bytes
338 if ( error
== NET_NO_DATA
)
340 else if ( error
== NET_CONN_ERROR
)
342 //fatal connection issue, exit
343 jack_error ( "'%s' : %s, exiting.", fParams
.fName
, StrError ( NET_ERROR_CODE
) );
344 //ask to the manager to properly remove the master
347 // UGLY temporary way to be sure the thread does not call code possibly causing a deadlock in JackEngine.
351 jack_error ( "Error in master receive : %s", StrError ( NET_ERROR_CODE
) );
354 packet_header_t
* header
= reinterpret_cast<packet_header_t
*>(fRxBuffer
);
355 PacketHeaderNToH(header
, header
);
359 int JackNetMasterInterface::Send ( size_t size
, int flags
)
362 packet_header_t
* header
= reinterpret_cast<packet_header_t
*>(fTxBuffer
);
363 PacketHeaderHToN(header
, header
);
365 if ( ( ( tx_bytes
= fSocket
.Send ( fTxBuffer
, size
, flags
) ) == SOCKET_ERROR
) && fRunning
)
367 net_error_t error
= fSocket
.GetError();
368 if ( error
== NET_CONN_ERROR
)
370 //fatal connection issue, exit
371 jack_error ( "'%s' : %s, exiting.", fParams
.fName
, StrError ( NET_ERROR_CODE
) );
374 // UGLY temporary way to be sure the thread does not call code possibly causing a deadlock in JackEngine.
378 jack_error ( "Error in master send : %s", StrError ( NET_ERROR_CODE
) );
383 bool JackNetMasterInterface::IsSynched()
385 if (fParams
.fNetworkMode
== 's') {
386 return (fCycleOffset
< 3);
392 int JackNetMasterInterface::SyncSend()
395 fTxHeader
.fSubCycle
= 0;
396 fTxHeader
.fDataType
= 's';
397 fTxHeader
.fIsLastPckt
= ( fParams
.fSendMidiChannels
== 0 && fParams
.fSendAudioChannels
== 0) ? 1 : 0;
398 fTxHeader
.fPacketSize
= fParams
.fMtu
;
399 memcpy ( fTxBuffer
, &fTxHeader
, sizeof ( packet_header_t
) );
400 return Send ( fTxHeader
.fPacketSize
, 0 );
403 int JackNetMasterInterface::DataSend()
407 if ( fParams
.fSendMidiChannels
> 0)
409 //set global header fields and get the number of midi packets
410 fTxHeader
.fDataType
= 'm';
411 fTxHeader
.fMidiDataSize
= fNetMidiCaptureBuffer
->RenderFromJackPorts();
412 fTxHeader
.fNMidiPckt
= GetNMidiPckt();
413 for ( subproc
= 0; subproc
< fTxHeader
.fNMidiPckt
; subproc
++ )
415 fTxHeader
.fSubCycle
= subproc
;
416 fTxHeader
.fIsLastPckt
= ( ( subproc
== ( fTxHeader
.fNMidiPckt
- 1 ) ) && (fParams
.fSendAudioChannels
== 0)) ? 1 : 0;
417 fTxHeader
.fPacketSize
= sizeof ( packet_header_t
) + fNetMidiCaptureBuffer
->RenderToNetwork ( subproc
, fTxHeader
.fMidiDataSize
);
418 memcpy ( fTxBuffer
, &fTxHeader
, sizeof ( packet_header_t
) );
419 if ( Send ( fTxHeader
.fPacketSize
, 0 ) == SOCKET_ERROR
)
425 if ( fParams
.fSendAudioChannels
> 0)
427 fTxHeader
.fDataType
= 'a';
428 fTxHeader
.fMidiDataSize
= 0;
429 fTxHeader
.fNMidiPckt
= 0;
430 for ( subproc
= 0; subproc
< fNSubProcess
; subproc
++ )
432 fTxHeader
.fSubCycle
= subproc
;
433 fTxHeader
.fIsLastPckt
= ( subproc
== ( fNSubProcess
- 1 ) ) ? 1 : 0;
434 fTxHeader
.fPacketSize
= fAudioTxLen
;
435 memcpy ( fTxBuffer
, &fTxHeader
, sizeof ( packet_header_t
) );
436 fNetAudioCaptureBuffer
->RenderFromJackPorts ( subproc
);
437 if ( Send ( fTxHeader
.fPacketSize
, 0 ) == SOCKET_ERROR
)
445 int JackNetMasterInterface::SyncRecv()
447 packet_header_t
* rx_head
= reinterpret_cast<packet_header_t
*> ( fRxBuffer
);
448 int rx_bytes
= Recv ( fParams
.fMtu
, MSG_PEEK
);
450 if ( ( rx_bytes
== 0 ) || ( rx_bytes
== SOCKET_ERROR
) )
453 fCycleOffset
= fTxHeader
.fCycle
- rx_head
->fCycle
;
455 switch ( fParams
.fNetworkMode
)
458 //slow mode : allow to use full bandwidth and heavy process on the slave
459 // - extra latency is set to two cycles, one cycle for send/receive operations + one cycle for heavy process on the slave
460 // - if the network is two fast, just wait the next cycle, this mode allows a shorter cycle duration for the master
461 // - this mode will skip the two first cycles, thus it lets time for data to be processed and queued on the socket rx buffer
462 //the slow mode is the safest mode because it wait twice the bandwidth relative time (send/return + process)
463 if (fCycleOffset
< 2)
466 rx_bytes
= Recv ( rx_head
->fPacketSize
, 0 );
468 if (fCycleOffset
> 2) {
469 jack_info("Warning : '%s' runs in slow network mode, but data received too late (%d cycle(s) offset)", fParams
.fName
, fCycleOffset
);
474 //normal use of the network :
475 // - extra latency is set to one cycle, what is the time needed to receive streams using full network bandwidth
476 // - if the network is too fast, just wait the next cycle, the benefit here is the master's cycle is shorter
477 // - indeed, data is supposed to be on the network rx buffer, so we don't have to wait for it
478 if (fCycleOffset
< 1)
481 rx_bytes
= Recv ( rx_head
->fPacketSize
, 0 );
483 if (fCycleOffset
!= 1)
484 jack_info("'%s' can't run in normal network mode, data received too late (%d cycle(s) offset)", fParams
.fName
, fCycleOffset
);
488 //fast mode suppose the network bandwith is larger than required for the transmission (only a few channels for example)
489 // - packets can be quickly received, quickly is here relative to the cycle duration
490 // - here, receive data, we can't keep it queued on the rx buffer,
491 // - but if there is a cycle offset, tell the user, that means we're not in fast mode anymore, network is too slow
492 rx_bytes
= Recv ( rx_head
->fPacketSize
, 0 );
494 if (fCycleOffset
!= 0)
495 jack_info("'%s' can't run in fast network mode, data received too late (%d cycle(s) offset)", fParams
.fName
, fCycleOffset
);
499 fRxHeader
.fIsLastPckt
= rx_head
->fIsLastPckt
;
503 int JackNetMasterInterface::DataRecv()
507 uint recvd_midi_pckt
= 0;
508 uint recvd_audio_pckt
= 0;
509 packet_header_t
* rx_head
= reinterpret_cast<packet_header_t
*> ( fRxBuffer
);
511 while ( !fRxHeader
.fIsLastPckt
)
513 //how much data is queued on the rx buffer ?
514 rx_bytes
= Recv ( fParams
.fMtu
, MSG_PEEK
);
516 if ( rx_bytes
== SOCKET_ERROR
)
519 if ( ( rx_bytes
== 0 ) && ( ++jumpcnt
== fNSubProcess
) )
521 jack_error ( "No data from %s...", fParams
.fName
);
524 //else if data is valid,
525 if ( rx_bytes
&& ( rx_head
->fDataStream
== 'r' ) && ( rx_head
->fID
== fParams
.fID
) )
528 switch ( rx_head
->fDataType
)
531 rx_bytes
= Recv ( rx_head
->fPacketSize
, 0 );
532 fRxHeader
.fCycle
= rx_head
->fCycle
;
533 fRxHeader
.fIsLastPckt
= rx_head
->fIsLastPckt
;
534 fNetMidiPlaybackBuffer
->RenderFromNetwork ( rx_head
->fSubCycle
, rx_bytes
- sizeof ( packet_header_t
) );
535 if ( ++recvd_midi_pckt
== rx_head
->fNMidiPckt
)
536 fNetMidiPlaybackBuffer
->RenderToJackPorts();
541 rx_bytes
= Recv ( rx_head
->fPacketSize
, 0 );
543 // if ( !IsNextPacket() )
544 // jack_error ( "Packet(s) missing from '%s'...", fParams.fName );
545 if (recvd_audio_pckt
++ != rx_head
->fSubCycle
) {
546 jack_error("Packet(s) missing from '%s'...", fParams
.fSlaveNetName
);
548 fRxHeader
.fCycle
= rx_head
->fCycle
;
549 fRxHeader
.fSubCycle
= rx_head
->fSubCycle
;
550 fRxHeader
.fIsLastPckt
= rx_head
->fIsLastPckt
;
551 fNetAudioPlaybackBuffer
->RenderToJackPorts ( rx_head
->fSubCycle
);
557 if ( rx_head->fCycle == fTxHeader.fCycle )
560 jack_info("NetMaster : overloaded, skipping receive from '%s'", fParams
.fName
);
568 void JackNetMasterInterface::EncodeSyncPacket()
570 //this method contains every step of sync packet informations coding
571 //first of all, reset sync packet
572 memset ( fTxData
, 0, fPayloadSize
);
574 //then, first step : transport
575 if (fParams
.fTransportSync
) {
576 EncodeTransportData();
577 TransportDataHToN( &fSendTransportData
, &fSendTransportData
);
579 memcpy ( fTxData
, &fSendTransportData
, sizeof ( net_transport_data_t
) );
581 //then others (freewheel etc.)
585 void JackNetMasterInterface::DecodeSyncPacket()
587 //this method contains every step of sync packet informations decoding process
589 if (fParams
.fTransportSync
) {
590 //copy received transport data to transport data structure
591 memcpy ( &fReturnTransportData
, fRxData
, sizeof ( net_transport_data_t
) );
592 TransportDataNToH( &fReturnTransportData
, &fReturnTransportData
);
593 DecodeTransportData();
599 // JackNetSlaveInterface ************************************************************************************************
601 uint
JackNetSlaveInterface::fSlaveCounter
= 0;
603 bool JackNetSlaveInterface::Init()
605 jack_log ( "JackNetSlaveInterface::Init()" );
607 //set the parameters to send
608 strcpy ( fParams
.fPacketType
, "params" );
609 fParams
.fProtocolVersion
= SLAVE_PROTOCOL
;
610 SetPacketType ( &fParams
, SLAVE_AVAILABLE
);
612 //init loop : get a master and start, do it until connection is ok
616 //first, get a master, do it until a valid connection is running
619 status
= SendAvailableToMaster();
620 if ( status
== NET_SOCKET_ERROR
)
623 while ( status
!= NET_CONNECTED
);
625 //then tell the master we are ready
626 jack_info ( "Initializing connection with %s...", fParams
.fMasterNetName
);
627 status
= SendStartToMaster();
628 if ( status
== NET_ERROR
)
631 while ( status
!= NET_ROLLING
);
636 // Separate the connection protocol into two separated step
638 bool JackNetSlaveInterface::InitConnection()
640 jack_log ( "JackNetSlaveInterface::InitConnection()" );
642 //set the parameters to send
643 strcpy (fParams
.fPacketType
, "params");
644 fParams
.fProtocolVersion
= SLAVE_PROTOCOL
;
645 SetPacketType (&fParams
, SLAVE_AVAILABLE
);
651 status
= SendAvailableToMaster();
652 if (status
== NET_SOCKET_ERROR
)
655 while (status
!= NET_CONNECTED
);
660 bool JackNetSlaveInterface::InitRendering()
662 jack_log("JackNetSlaveInterface::InitRendering()");
667 //then tell the master we are ready
668 jack_info("Initializing connection with %s...", fParams
.fMasterNetName
);
669 status
= SendStartToMaster();
670 if (status
== NET_ERROR
)
673 while (status
!= NET_ROLLING
);
678 net_status_t
JackNetSlaveInterface::SendAvailableToMaster()
680 jack_log ( "JackNetSlaveInterface::SendAvailableToMaster()" );
682 session_params_t host_params
;
686 if ( fSocket
.NewSocket() == SOCKET_ERROR
) {
687 jack_error ( "Fatal error : network unreachable - %s", StrError ( NET_ERROR_CODE
) );
688 return NET_SOCKET_ERROR
;
692 if ( fSocket
.Bind() == SOCKET_ERROR
) {
693 jack_error ( "Can't bind the socket : %s", StrError ( NET_ERROR_CODE
) );
694 return NET_SOCKET_ERROR
;
698 if ( fSocket
.SetTimeOut ( SLAVE_INIT_TIMEOUT
) == SOCKET_ERROR
)
699 jack_error ( "Can't set timeout : %s", StrError ( NET_ERROR_CODE
) );
702 if ( fSocket
.SetLocalLoop() == SOCKET_ERROR
)
703 jack_error ( "Can't disable multicast loop : %s", StrError ( NET_ERROR_CODE
) );
705 //send 'AVAILABLE' until 'SLAVE_SETUP' received
706 jack_info ( "Waiting for a master..." );
710 session_params_t net_params
;
711 memset(&net_params
, 0, sizeof ( session_params_t
));
712 SessionParamsHToN(&fParams
, &net_params
);
713 if ( fSocket
.SendTo ( &net_params
, sizeof ( session_params_t
), 0, fMulticastIP
) == SOCKET_ERROR
)
714 jack_error ( "Error in data send : %s", StrError ( NET_ERROR_CODE
) );
716 //filter incoming packets : don't exit while no error is detected
717 memset(&net_params
, 0, sizeof ( session_params_t
));
718 rx_bytes
= fSocket
.CatchHost ( &net_params
, sizeof ( session_params_t
), 0 );
719 SessionParamsNToH(&net_params
, &host_params
);
720 if ( ( rx_bytes
== SOCKET_ERROR
) && ( fSocket
.GetError() != NET_NO_DATA
) )
722 jack_error ( "Can't receive : %s", StrError ( NET_ERROR_CODE
) );
723 return NET_RECV_ERROR
;
726 while ( strcmp ( host_params
.fPacketType
, fParams
.fPacketType
) && ( GetPacketType ( &host_params
) != SLAVE_SETUP
) );
728 //everything is OK, copy parameters
729 fParams
= host_params
;
731 //set the new buffer sizes
732 if ( SetNetBufferSize() == SOCKET_ERROR
) {
733 jack_error ( "Can't set net buffer sizes : %s", StrError ( NET_ERROR_CODE
) );
734 return NET_SOCKET_ERROR
;
738 if ( fSocket
.Connect() == SOCKET_ERROR
) {
739 jack_error ( "Error in connect : %s", StrError ( NET_ERROR_CODE
) );
740 return NET_CONNECT_ERROR
;
743 return NET_CONNECTED
;
746 net_status_t
JackNetSlaveInterface::SendStartToMaster()
748 jack_log ( "JackNetSlaveInterface::SendStartToMaster" );
750 //tell the master to start
751 session_params_t net_params
;
752 memset(&net_params
, 0, sizeof ( session_params_t
));
753 SetPacketType ( &fParams
, START_MASTER
);
754 SessionParamsHToN(&fParams
, &net_params
);
755 if ( fSocket
.Send ( &net_params
, sizeof ( session_params_t
), 0 ) == SOCKET_ERROR
)
757 jack_error ( "Error in send : %s", StrError ( NET_ERROR_CODE
) );
758 return ( fSocket
.GetError() == NET_CONN_ERROR
) ? NET_ERROR
: NET_SEND_ERROR
;
763 void JackNetSlaveInterface::SetParams()
765 jack_log ( "JackNetSlaveInterface::SetParams" );
767 JackNetInterface::SetParams();
769 fTxHeader
.fDataStream
= 'r';
770 fRxHeader
.fDataStream
= 's';
773 fNetMidiCaptureBuffer
= new NetMidiBuffer ( &fParams
, fParams
.fSendMidiChannels
, fRxData
);
774 fNetMidiPlaybackBuffer
= new NetMidiBuffer ( &fParams
, fParams
.fReturnMidiChannels
, fTxData
);
777 fNetAudioCaptureBuffer
= new NetAudioBuffer ( &fParams
, fParams
.fSendAudioChannels
, fRxData
);
778 fNetAudioPlaybackBuffer
= new NetAudioBuffer ( &fParams
, fParams
.fReturnAudioChannels
, fTxData
);
780 //audio netbuffer length
781 fAudioTxLen
= sizeof ( packet_header_t
) + fNetAudioPlaybackBuffer
->GetSize();
782 fAudioRxLen
= sizeof ( packet_header_t
) + fNetAudioCaptureBuffer
->GetSize();
785 int JackNetSlaveInterface::Recv ( size_t size
, int flags
)
787 int rx_bytes
= fSocket
.Recv ( fRxBuffer
, size
, flags
);
789 if ( rx_bytes
== SOCKET_ERROR
)
791 net_error_t error
= fSocket
.GetError();
792 //no data isn't really an error in realtime processing, so just return 0
793 if ( error
== NET_NO_DATA
)
794 jack_error ( "No data, is the master still running ?" );
795 //if a network error occurs, this exception will restart the driver
796 else if ( error
== NET_CONN_ERROR
)
798 jack_error ( "Connection lost." );
799 throw JackNetException();
802 jack_error ( "Fatal error in slave receive : %s", StrError ( NET_ERROR_CODE
) );
805 packet_header_t
* header
= reinterpret_cast<packet_header_t
*>(fRxBuffer
);
806 PacketHeaderNToH(header
, header
);
810 int JackNetSlaveInterface::Send ( size_t size
, int flags
)
812 packet_header_t
* header
= reinterpret_cast<packet_header_t
*>(fTxBuffer
);
813 PacketHeaderHToN(header
, header
);
814 int tx_bytes
= fSocket
.Send ( fTxBuffer
, size
, flags
);
817 if ( tx_bytes
== SOCKET_ERROR
)
819 net_error_t error
= fSocket
.GetError();
820 //if a network error occurs, this exception will restart the driver
821 if ( error
== NET_CONN_ERROR
)
823 jack_error ( "Connection lost." );
824 throw JackNetException();
827 jack_error ( "Fatal error in slave send : %s", StrError ( NET_ERROR_CODE
) );
832 int JackNetSlaveInterface::SyncRecv()
835 packet_header_t
* rx_head
= reinterpret_cast<packet_header_t
*> ( fRxBuffer
);
836 //receive sync (launch the cycle)
839 rx_bytes
= Recv ( fParams
.fMtu
, 0 );
840 //connection issue, send will detect it, so don't skip the cycle (return 0)
841 if ( rx_bytes
== SOCKET_ERROR
)
844 while ((strcmp(rx_head
->fPacketType
, "header") != 0) && (rx_head
->fDataType
!= 's'));
846 fRxHeader
.fIsLastPckt
= rx_head
->fIsLastPckt
;
850 int JackNetSlaveInterface::DataRecv()
852 uint recvd_midi_pckt
= 0;
853 uint recvd_audio_pckt
= 0;
855 packet_header_t
* rx_head
= reinterpret_cast<packet_header_t
*> ( fRxBuffer
);
857 while ( !fRxHeader
.fIsLastPckt
)
859 rx_bytes
= Recv ( fParams
.fMtu
, MSG_PEEK
);
860 //error here, problem with recv, just skip the cycle (return -1)
862 if ( rx_bytes
== SOCKET_ERROR
)
864 if ( rx_bytes
&& ( rx_head
->fDataStream
== 's' ) && ( rx_head
->fID
== fParams
.fID
) )
866 switch ( rx_head
->fDataType
)
869 rx_bytes
= Recv ( rx_head
->fPacketSize
, 0 );
870 fRxHeader
.fCycle
= rx_head
->fCycle
;
871 fRxHeader
.fIsLastPckt
= rx_head
->fIsLastPckt
;
872 fNetMidiCaptureBuffer
->RenderFromNetwork ( rx_head
->fSubCycle
, rx_bytes
- sizeof ( packet_header_t
) );
873 if ( ++recvd_midi_pckt
== rx_head
->fNMidiPckt
)
874 fNetMidiCaptureBuffer
->RenderToJackPorts();
878 rx_bytes
= Recv ( rx_head
->fPacketSize
, 0 );
880 // if ( !IsNextPacket() )
881 // jack_error ( "Packet(s) missing..." );
882 if (recvd_audio_pckt
++ != rx_head
->fSubCycle
) {
883 jack_error("Packet(s) missing from '%s'...", fParams
.fMasterNetName
);
885 fRxHeader
.fCycle
= rx_head
->fCycle
;
886 fRxHeader
.fSubCycle
= rx_head
->fSubCycle
;
887 fRxHeader
.fIsLastPckt
= rx_head
->fIsLastPckt
;
888 fNetAudioCaptureBuffer
->RenderToJackPorts ( rx_head
->fSubCycle
);
892 jack_info ( "NetSlave : overloaded, skipping receive." );
897 fRxHeader
.fCycle
= rx_head
->fCycle
;
901 int JackNetSlaveInterface::SyncSend()
904 if ( fParams
.fSlaveSyncMode
)
905 fTxHeader
.fCycle
= fRxHeader
.fCycle
;
908 fTxHeader
.fSubCycle
= 0;
909 fTxHeader
.fDataType
= 's';
910 fTxHeader
.fIsLastPckt
= ( fParams
.fReturnMidiChannels
== 0 && fParams
.fReturnAudioChannels
== 0) ? 1 : 0;
911 fTxHeader
.fPacketSize
= fParams
.fMtu
;
912 memcpy ( fTxBuffer
, &fTxHeader
, sizeof ( packet_header_t
) );
913 return Send ( fTxHeader
.fPacketSize
, 0 );
916 int JackNetSlaveInterface::DataSend()
921 if ( fParams
.fReturnMidiChannels
> 0)
923 fTxHeader
.fDataType
= 'm';
924 fTxHeader
.fMidiDataSize
= fNetMidiPlaybackBuffer
->RenderFromJackPorts();
925 fTxHeader
.fNMidiPckt
= GetNMidiPckt();
926 for ( subproc
= 0; subproc
< fTxHeader
.fNMidiPckt
; subproc
++ )
928 fTxHeader
.fSubCycle
= subproc
;
929 fTxHeader
.fIsLastPckt
= ( ( subproc
== ( fTxHeader
.fNMidiPckt
- 1 ) ) && !fParams
.fReturnAudioChannels
) ? 1 : 0;
930 fTxHeader
.fPacketSize
= sizeof ( packet_header_t
) + fNetMidiPlaybackBuffer
->RenderToNetwork ( subproc
, fTxHeader
.fMidiDataSize
);
931 memcpy ( fTxBuffer
, &fTxHeader
, sizeof ( packet_header_t
) );
932 if ( Send ( fTxHeader
.fPacketSize
, 0 ) == SOCKET_ERROR
)
938 if ( fParams
.fReturnAudioChannels
> 0)
940 fTxHeader
.fDataType
= 'a';
941 fTxHeader
.fMidiDataSize
= 0;
942 fTxHeader
.fNMidiPckt
= 0;
943 for ( subproc
= 0; subproc
< fNSubProcess
; subproc
++ )
945 fTxHeader
.fSubCycle
= subproc
;
946 fTxHeader
.fIsLastPckt
= ( subproc
== ( fNSubProcess
- 1 ) ) ? 1 : 0;
947 fTxHeader
.fPacketSize
= fAudioTxLen
;
948 memcpy ( fTxBuffer
, &fTxHeader
, sizeof ( packet_header_t
) );
949 fNetAudioPlaybackBuffer
->RenderFromJackPorts ( subproc
);
950 if ( Send ( fTxHeader
.fPacketSize
, 0 ) == SOCKET_ERROR
)
957 //network sync------------------------------------------------------------------------
958 void JackNetSlaveInterface::EncodeSyncPacket()
960 //this method contains every step of sync packet informations coding
961 //first of all, reset sync packet
962 memset ( fTxData
, 0, fPayloadSize
);
963 //then first step : transport
964 if (fParams
.fTransportSync
) {
965 EncodeTransportData();
966 TransportDataHToN( &fReturnTransportData
, &fReturnTransportData
);
968 memcpy ( fTxData
, &fReturnTransportData
, sizeof ( net_transport_data_t
) );
974 void JackNetSlaveInterface::DecodeSyncPacket()
976 //this method contains every step of sync packet informations decoding process
978 if (fParams
.fTransportSync
) {
979 //copy received transport data to transport data structure
980 memcpy ( &fSendTransportData
, fRxData
, sizeof ( net_transport_data_t
) );
981 TransportDataNToH( &fSendTransportData
, &fSendTransportData
);
982 DecodeTransportData();