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"
27 #define PACKET_AVAILABLE_SIZE (fParams.fMtu - sizeof(packet_header_t))
28 #define HEADER_SIZE (sizeof(packet_header_t))
31 TODO : since midi buffers now uses up to BUFFER_SIZE_MAX frames,
32 probably also use BUFFER_SIZE_MAX in everything related to MIDI events
33 handling (see MidiBufferInit in JackMidiPort.cpp)
38 // JackNetInterface*******************************************
40 JackNetInterface::JackNetInterface() : fSocket()
45 JackNetInterface::JackNetInterface ( const char* multicast_ip
, int port
) : fSocket ( multicast_ip
, port
)
47 strcpy(fMulticastIP
, multicast_ip
);
51 JackNetInterface::JackNetInterface ( session_params_t
& params
, JackNetSocket
& socket
, const char* multicast_ip
) : fSocket ( socket
)
54 strcpy(fMulticastIP
, multicast_ip
);
58 void JackNetInterface::Initialize()
62 fNetAudioCaptureBuffer
= NULL
;
63 fNetAudioPlaybackBuffer
= NULL
;
64 fNetMidiCaptureBuffer
= NULL
;
65 fNetMidiPlaybackBuffer
= NULL
;
66 memset(&fSendTransportData
, 0, sizeof(net_transport_data_t
));
67 memset(&fReturnTransportData
, 0, sizeof(net_transport_data_t
));
70 void JackNetInterface::FreeNetworkBuffers()
72 delete fNetMidiCaptureBuffer
;
73 delete fNetMidiPlaybackBuffer
;
74 delete fNetAudioCaptureBuffer
;
75 delete fNetAudioPlaybackBuffer
;
76 fNetMidiCaptureBuffer
= NULL
;
77 fNetMidiPlaybackBuffer
= NULL
;
78 fNetAudioCaptureBuffer
= NULL
;
79 fNetAudioPlaybackBuffer
= NULL
;
82 JackNetInterface::~JackNetInterface()
84 jack_log ("JackNetInterface::~JackNetInterface");
89 delete fNetAudioCaptureBuffer
;
90 delete fNetAudioPlaybackBuffer
;
91 delete fNetMidiCaptureBuffer
;
92 delete fNetMidiPlaybackBuffer
;
95 int JackNetInterface::SetNetBufferSize()
98 float audio_size
= (fNetAudioCaptureBuffer
)
99 ? fNetAudioCaptureBuffer
->GetCycleSize()
100 : (fNetAudioPlaybackBuffer
) ? fNetAudioPlaybackBuffer
->GetCycleSize() : 0;
101 jack_log("audio_size %f", audio_size
);
104 float midi_size
= (fNetMidiCaptureBuffer
)
105 ? fNetMidiCaptureBuffer
->GetCycleSize()
106 : (fNetMidiPlaybackBuffer
) ? fNetMidiPlaybackBuffer
->GetCycleSize() : 0;
107 jack_log("midi_size %f", midi_size
);
109 //bufsize = sync + audio + midi
110 int bufsize
= MAX_LATENCY
* (fParams
.fMtu
+ (int)audio_size
+ (int) midi_size
);
111 jack_log("SetNetBufferSize bufsize = %d", bufsize
);
114 if (fSocket
.SetOption(SOL_SOCKET
, SO_SNDBUF
, &bufsize
, sizeof(bufsize
)) == SOCKET_ERROR
)
118 if (fSocket
.SetOption(SOL_SOCKET
, SO_RCVBUF
, &bufsize
, sizeof(bufsize
)) == SOCKET_ERROR
)
124 bool JackNetInterface::SetParams()
127 strcpy ( fTxHeader
.fPacketType
, "header" );
128 fTxHeader
.fID
= fParams
.fID
;
129 fTxHeader
.fCycle
= 0;
130 fTxHeader
.fSubCycle
= 0;
131 fTxHeader
.fIsLastPckt
= 0;
134 strcpy ( fRxHeader
.fPacketType
, "header" );
135 fRxHeader
.fID
= fParams
.fID
;
136 fRxHeader
.fCycle
= 0;
137 fRxHeader
.fSubCycle
= 0;
138 fRxHeader
.fIsLastPckt
= 0;
141 fTxBuffer
= new char[fParams
.fMtu
];
142 fRxBuffer
= new char[fParams
.fMtu
];
143 assert ( fTxBuffer
);
144 assert ( fRxBuffer
);
146 //net audio/midi buffers'addresses
147 fTxData
= fTxBuffer
+ HEADER_SIZE
;
148 fRxData
= fRxBuffer
+ HEADER_SIZE
;
153 // JackNetMasterInterface ************************************************************************************
155 bool JackNetMasterInterface::Init()
157 jack_log ( "JackNetMasterInterface::Init, ID %u.", fParams
.fID
);
159 session_params_t host_params
;
164 if ( fSocket
.NewSocket() == SOCKET_ERROR
) {
165 jack_error ( "Can't create socket : %s", StrError ( NET_ERROR_CODE
) );
169 //timeout on receive (for init)
170 if ( fSocket
.SetTimeOut ( MASTER_INIT_TIMEOUT
) < 0 )
171 jack_error ( "Can't set timeout : %s", StrError ( NET_ERROR_CODE
) );
174 if ( fSocket
.Connect() == SOCKET_ERROR
) {
175 jack_error ( "Can't connect : %s", StrError ( NET_ERROR_CODE
) );
179 //send 'SLAVE_SETUP' until 'START_MASTER' received
180 jack_info ( "Sending parameters to %s...", fParams
.fSlaveNetName
);
183 session_params_t net_params
;
184 memset(&net_params
, 0, sizeof ( session_params_t
));
185 SetPacketType ( &fParams
, SLAVE_SETUP
);
186 SessionParamsHToN(&fParams
, &net_params
);
188 if ( fSocket
.Send ( &net_params
, sizeof ( session_params_t
), 0 ) == SOCKET_ERROR
)
189 jack_error ( "Error in send : ", StrError ( NET_ERROR_CODE
) );
191 memset(&net_params
, 0, sizeof (session_params_t
));
192 if (((rx_bytes
= fSocket
.Recv(&net_params
, sizeof(session_params_t
), 0)) == SOCKET_ERROR
) && (fSocket
.GetError() != NET_NO_DATA
))
194 jack_error ( "Problem with network." );
198 SessionParamsNToH(&net_params
, &host_params
);
200 while ( ( GetPacketType ( &host_params
) != START_MASTER
) && ( ++attempt
< SLAVE_SETUP_RETRY
) );
201 if ( attempt
== SLAVE_SETUP_RETRY
) {
202 jack_error ( "Slave doesn't respond, exiting." );
209 int JackNetMasterInterface::SetRxTimeout()
211 jack_log ( "JackNetMasterInterface::SetRxTimeout" );
215 //slow or normal mode, short timeout on recv (2 audio subcycles)
216 if ((fParams
.fNetworkMode
== 's') || (fParams
.fNetworkMode
== 'n')) {
217 time
= 2000000.f
* ((fNetAudioCaptureBuffer
)
218 ? fNetAudioCaptureBuffer
->GetCycleDuration()
219 : (fNetAudioPlaybackBuffer
) ? fNetAudioPlaybackBuffer
->GetCycleDuration() : 0);
221 //fast mode, wait for 75% of the entire cycle duration
222 else if (fParams
.fNetworkMode
== 'f') {
223 time
= 750000.f
* (static_cast<float>(fParams
.fPeriodSize
) / static_cast<float>(fParams
.fSampleRate
));
226 return fSocket
.SetTimeOut (static_cast<int>(time
));
229 bool JackNetMasterInterface::SetParams()
231 jack_log("JackNetMasterInterface::SetParams");
233 JackNetInterface::SetParams();
235 fTxHeader
.fDataStream
= 's';
236 fRxHeader
.fDataStream
= 'r';
239 if (fParams
.fSendMidiChannels
)
240 fNetMidiCaptureBuffer
= new NetMidiBuffer(&fParams
, fParams
.fSendMidiChannels
, fTxData
);
242 if (fParams
.fReturnMidiChannels
)
243 fNetMidiPlaybackBuffer
= new NetMidiBuffer(&fParams
, fParams
.fReturnMidiChannels
, fRxData
);
248 if (fParams
.fSendAudioChannels
) {
250 switch (fParams
.fSampleEncoder
) {
252 case JackFloatEncoder
:
253 fNetAudioCaptureBuffer
= new NetFloatAudioBuffer(&fParams
, fParams
.fSendAudioChannels
, fTxData
);
257 fNetAudioCaptureBuffer
= new NetIntAudioBuffer(&fParams
, fParams
.fSendAudioChannels
, fTxData
);
260 case JackCeltEncoder
:
262 fNetAudioCaptureBuffer
= new NetCeltAudioBuffer(&fParams
, fParams
.fSendAudioChannels
, fTxData
, fParams
.fKBps
);
267 assert(fNetAudioCaptureBuffer
);
270 if (fParams
.fReturnAudioChannels
) {
272 switch (fParams
.fSampleEncoder
) {
274 case JackFloatEncoder
:
275 fNetAudioPlaybackBuffer
= new NetFloatAudioBuffer(&fParams
, fParams
.fReturnAudioChannels
, fRxData
);
279 fNetAudioPlaybackBuffer
= new NetIntAudioBuffer(&fParams
, fParams
.fReturnAudioChannels
, fRxData
);
282 case JackCeltEncoder
:
284 fNetAudioPlaybackBuffer
= new NetCeltAudioBuffer(&fParams
, fParams
.fReturnAudioChannels
, fRxData
, fParams
.fKBps
);
289 assert(fNetAudioPlaybackBuffer
);
292 } catch (exception
&) {
293 jack_error("NetAudioBuffer allocation error...");
297 //set the new timeout for the socket
298 if (SetRxTimeout() == SOCKET_ERROR
) {
299 jack_error("Can't set rx timeout : %s", StrError(NET_ERROR_CODE
));
303 //set the new rx buffer size
304 if (SetNetBufferSize() == SOCKET_ERROR
) {
305 jack_error("Can't set net buffer sizes : %s", StrError(NET_ERROR_CODE
));
312 FreeNetworkBuffers();
316 void JackNetMasterInterface::Exit()
318 jack_log ( "JackNetMasterInterface::Exit, ID %u", fParams
.fID
);
323 //send a 'multicast euthanasia request' - new socket is required on macosx
324 jack_info ( "Exiting '%s'", fParams
.fName
);
325 SetPacketType ( &fParams
, KILL_MASTER
);
326 JackNetSocket
mcast_socket ( fMulticastIP
, fSocket
.GetPort() );
328 session_params_t net_params
;
329 memset(&net_params
, 0, sizeof ( session_params_t
));
330 SessionParamsHToN(&fParams
, &net_params
);
332 if ( mcast_socket
.NewSocket() == SOCKET_ERROR
)
333 jack_error ( "Can't create socket : %s", StrError ( NET_ERROR_CODE
) );
334 if ( mcast_socket
.SendTo ( &net_params
, sizeof ( session_params_t
), 0, fMulticastIP
) == SOCKET_ERROR
)
335 jack_error ( "Can't send suicide request : %s", StrError ( NET_ERROR_CODE
) );
337 mcast_socket
.Close();
340 int JackNetMasterInterface::Recv(size_t size
, int flags
)
344 if ((( rx_bytes
= fSocket
.Recv(fRxBuffer
, size
, flags
)) == SOCKET_ERROR
) && fRunning
) {
345 net_error_t error
= fSocket
.GetError();
346 //no data isn't really a network error, so just return 0 available read bytes
347 if (error
== NET_NO_DATA
) {
349 } else if (error
== NET_CONN_ERROR
) {
350 //fatal connection issue, exit
351 jack_error ( "'%s' : %s, exiting.", fParams
.fName
, StrError(NET_ERROR_CODE
));
352 //ask to the manager to properly remove the master
355 // UGLY temporary way to be sure the thread does not call code possibly causing a deadlock in JackEngine.
358 jack_error ( "Error in master receive : %s", StrError(NET_ERROR_CODE
));
362 packet_header_t
* header
= reinterpret_cast<packet_header_t
*>(fRxBuffer
);
363 PacketHeaderNToH(header
, header
);
367 int JackNetMasterInterface::Send(size_t size
, int flags
)
370 packet_header_t
* header
= reinterpret_cast<packet_header_t
*>(fTxBuffer
);
371 PacketHeaderHToN(header
, header
);
373 if (((tx_bytes
= fSocket
.Send(fTxBuffer
, size
, flags
)) == SOCKET_ERROR
) && fRunning
) {
374 net_error_t error
= fSocket
.GetError();
375 if (error
== NET_CONN_ERROR
) {
376 //fatal connection issue, exit
377 jack_error ("'%s' : %s, exiting.", fParams
.fName
, StrError (NET_ERROR_CODE
));
380 // UGLY temporary way to be sure the thread does not call code possibly causing a deadlock in JackEngine.
383 jack_error("Error in master send : %s", StrError(NET_ERROR_CODE
));
389 bool JackNetMasterInterface::IsSynched()
391 if (fParams
.fNetworkMode
== 's') {
392 return (fCycleOffset
< (CYCLE_OFFSET_SLOW
+ 1));
398 int JackNetMasterInterface::SyncSend()
401 fTxHeader
.fSubCycle
= 0;
402 fTxHeader
.fDataType
= 's';
403 fTxHeader
.fIsLastPckt
= (fParams
.fSendMidiChannels
== 0 && fParams
.fSendAudioChannels
== 0) ? 1 : 0;
404 fTxHeader
.fPacketSize
= HEADER_SIZE
;
406 memcpy(fTxBuffer
, &fTxHeader
, HEADER_SIZE
);
407 return Send(fTxHeader
.fPacketSize
, 0);
410 int JackNetMasterInterface::DataSend()
416 if (fParams
.fSendMidiChannels
> 0)
418 //set global header fields and get the number of midi packets
419 fTxHeader
.fDataType
= 'm';
420 data_size
= fNetMidiCaptureBuffer
->RenderFromJackPorts();
421 fTxHeader
.fNumPacket
= fNetMidiCaptureBuffer
->GetNumPackets();
423 for ( subproc
= 0; subproc
< fTxHeader
.fNumPacket
; subproc
++ )
425 fTxHeader
.fSubCycle
= subproc
;
426 fTxHeader
.fIsLastPckt
= ((subproc
== (fTxHeader
.fNumPacket
- 1)) && (fParams
.fSendAudioChannels
== 0)) ? 1 : 0;
427 fTxHeader
.fPacketSize
= HEADER_SIZE
+ fNetMidiCaptureBuffer
->RenderToNetwork(subproc
, data_size
);
428 memcpy ( fTxBuffer
, &fTxHeader
, HEADER_SIZE
);
429 if (Send (fTxHeader
.fPacketSize
, 0) == SOCKET_ERROR
)
435 if (fParams
.fSendAudioChannels
> 0)
437 fTxHeader
.fDataType
= 'a';
438 data_size
= fNetAudioCaptureBuffer
->RenderFromJackPorts();
439 fTxHeader
.fNumPacket
= fNetAudioCaptureBuffer
->GetNumPackets();
441 for (subproc
= 0; subproc
< fTxHeader
.fNumPacket
; subproc
++)
443 fTxHeader
.fSubCycle
= subproc
;
444 fTxHeader
.fIsLastPckt
= (subproc
== (fTxHeader
.fNumPacket
- 1)) ? 1 : 0;
445 fTxHeader
.fPacketSize
= HEADER_SIZE
+ fNetAudioCaptureBuffer
->RenderToNetwork(subproc
, data_size
);
446 memcpy(fTxBuffer
, &fTxHeader
, HEADER_SIZE
);
447 if (Send(fTxHeader
.fPacketSize
, 0) == SOCKET_ERROR
)
455 int JackNetMasterInterface::SyncRecv()
457 packet_header_t
* rx_head
= reinterpret_cast<packet_header_t
*> ( fRxBuffer
);
458 int rx_bytes
= Recv(HEADER_SIZE
, MSG_PEEK
);
460 if ( ( rx_bytes
== 0 ) || ( rx_bytes
== SOCKET_ERROR
) )
463 fCycleOffset
= fTxHeader
.fCycle
- rx_head
->fCycle
;
465 switch ( fParams
.fNetworkMode
)
468 //slow mode : allow to use full bandwidth and heavy process on the slave
469 // - extra latency is set to two cycles, one cycle for send/receive operations + one cycle for heavy process on the slave
470 // - if the network is two fast, just wait the next cycle, this mode allows a shorter cycle duration for the master
471 // - this mode will skip the two first cycles, thus it lets time for data to be processed and queued on the socket rx buffer
472 //the slow mode is the safest mode because it wait twice the bandwidth relative time (send/return + process)
475 if (fCycleOffset < CYCLE_OFFSET_SLOW) {
478 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
482 rx_bytes
= Recv ( rx_head
->fPacketSize
, 0 );
484 if (fCycleOffset
!= fLastfCycleOffset
)
485 jack_info("Warning : '%s' runs in slow network mode, but data received too late (%d cycle(s) offset)", fParams
.fName
, fCycleOffset
);
486 fLastfCycleOffset
= fCycleOffset
;
490 //normal use of the network :
491 // - extra latency is set to one cycle, what is the time needed to receive streams using full network bandwidth
492 // - if the network is too fast, just wait the next cycle, the benefit here is the master's cycle is shorter
493 // - indeed, data is supposed to be on the network rx buffer, so we don't have to wait for it
494 if (fCycleOffset
< CYCLE_OFFSET_NORMAL
) {
497 rx_bytes
= Recv ( rx_head
->fPacketSize
, 0 );
500 if (fCycleOffset
> CYCLE_OFFSET_NORMAL
) {
501 jack_info("'%s' can't run in normal network mode, data received too late (%d cycle(s) offset)", fParams
.fName
, fCycleOffset
);
506 //fast mode suppose the network bandwith is larger than required for the transmission (only a few channels for example)
507 // - packets can be quickly received, quickly is here relative to the cycle duration
508 // - here, receive data, we can't keep it queued on the rx buffer,
509 // - but if there is a cycle offset, tell the user, that means we're not in fast mode anymore, network is too slow
510 rx_bytes
= Recv ( rx_head
->fPacketSize
, 0 );
512 if (fCycleOffset
> CYCLE_OFFSET_FAST
) {
513 jack_info("'%s' can't run in fast network mode, data received too late (%d cycle(s) offset)", fParams
.fName
, fCycleOffset
);
519 fRxHeader
.fIsLastPckt
= rx_head
->fIsLastPckt
;
523 int JackNetMasterInterface::DataRecv()
526 uint recvd_midi_pckt
= 0;
527 packet_header_t
* rx_head
= reinterpret_cast<packet_header_t
*> ( fRxBuffer
);
529 while ( !fRxHeader
.fIsLastPckt
)
531 //how much data is queued on the rx buffer ?
532 rx_bytes
= Recv(HEADER_SIZE
, MSG_PEEK
);
534 //error here, problem with recv, just skip the cycle (return -1)
535 if ( rx_bytes
== SOCKET_ERROR
)
538 if ( rx_bytes
&& ( rx_head
->fDataStream
== 'r' ) && ( rx_head
->fID
== fParams
.fID
) )
541 switch ( rx_head
->fDataType
)
544 rx_bytes
= Recv(rx_head
->fPacketSize
, 0);
545 fRxHeader
.fCycle
= rx_head
->fCycle
;
546 fRxHeader
.fIsLastPckt
= rx_head
->fIsLastPckt
;
547 fNetMidiPlaybackBuffer
->RenderFromNetwork(rx_head
->fSubCycle
, rx_bytes
- HEADER_SIZE
);
548 // Last midi packet is received, so finish rendering...
549 if (++recvd_midi_pckt
== rx_head
->fNumPacket
)
550 fNetMidiPlaybackBuffer
->RenderToJackPorts();
554 rx_bytes
= Recv(rx_head
->fPacketSize
, 0);
555 fRxHeader
.fCycle
= rx_head
->fCycle
;
556 fRxHeader
.fSubCycle
= rx_head
->fSubCycle
;
557 fRxHeader
.fIsLastPckt
= rx_head
->fIsLastPckt
;
558 fNetAudioPlaybackBuffer
->RenderFromNetwork(rx_head
->fCycle
, rx_head
->fSubCycle
, rx_bytes
- HEADER_SIZE
);
559 // Last audio packet is received, so finish rendering...
560 if (fRxHeader
.fIsLastPckt
)
561 fNetAudioPlaybackBuffer
->RenderToJackPorts();
565 jack_info("NetMaster : overloaded, skipping receive from '%s'", fParams
.fName
);
566 // TODO : finish midi and audio rendering ?
567 fNetAudioPlaybackBuffer
->RenderToJackPorts();
576 void JackNetMasterInterface::EncodeSyncPacket()
578 //this method contains every step of sync packet informations coding
579 //first of all, reset sync packet
580 memset ( fTxData
, 0, PACKET_AVAILABLE_SIZE
);
582 //then, first step : transport
583 if (fParams
.fTransportSync
) {
584 EncodeTransportData();
585 TransportDataHToN( &fSendTransportData
, &fSendTransportData
);
587 memcpy ( fTxData
, &fSendTransportData
, sizeof ( net_transport_data_t
) );
589 //then others (freewheel etc.)
593 void JackNetMasterInterface::DecodeSyncPacket()
595 //this method contains every step of sync packet informations decoding process
597 if (fParams
.fTransportSync
) {
598 //copy received transport data to transport data structure
599 memcpy ( &fReturnTransportData
, fRxData
, sizeof ( net_transport_data_t
) );
600 TransportDataNToH( &fReturnTransportData
, &fReturnTransportData
);
601 DecodeTransportData();
607 // JackNetSlaveInterface ************************************************************************************************
609 uint
JackNetSlaveInterface::fSlaveCounter
= 0;
611 bool JackNetSlaveInterface::Init()
613 jack_log ( "JackNetSlaveInterface::Init()" );
615 //set the parameters to send
616 strcpy ( fParams
.fPacketType
, "params" );
617 fParams
.fProtocolVersion
= SLAVE_PROTOCOL
;
618 SetPacketType ( &fParams
, SLAVE_AVAILABLE
);
620 //init loop : get a master and start, do it until connection is ok
624 //first, get a master, do it until a valid connection is running
627 status
= SendAvailableToMaster();
628 if ( status
== NET_SOCKET_ERROR
)
631 while ( status
!= NET_CONNECTED
);
633 //then tell the master we are ready
634 jack_info ( "Initializing connection with %s...", fParams
.fMasterNetName
);
635 status
= SendStartToMaster();
636 if ( status
== NET_ERROR
)
639 while ( status
!= NET_ROLLING
);
644 // Separate the connection protocol into two separated step
645 bool JackNetSlaveInterface::InitConnection(int time_out
)
647 jack_log("JackNetSlaveInterface::InitConnection()");
648 int try_count
= (time_out
> 0) ? ((1000000 * time_out
) / SLAVE_INIT_TIMEOUT
) : LONG_MAX
;
650 //set the parameters to send
651 strcpy (fParams
.fPacketType
, "params");
652 fParams
.fProtocolVersion
= SLAVE_PROTOCOL
;
653 SetPacketType (&fParams
, SLAVE_AVAILABLE
);
659 status
= SendAvailableToMaster(try_count
);
660 if (status
== NET_SOCKET_ERROR
)
663 while (status
!= NET_CONNECTED
&& --try_count
> 0);
665 return (try_count
!= 0);
668 bool JackNetSlaveInterface::InitRendering()
670 jack_log("JackNetSlaveInterface::InitRendering()");
675 //then tell the master we are ready
676 jack_info("Initializing connection with %s...", fParams
.fMasterNetName
);
677 status
= SendStartToMaster();
678 if (status
== NET_ERROR
)
681 while (status
!= NET_ROLLING
);
686 net_status_t
JackNetSlaveInterface::SendAvailableToMaster(long try_count
)
688 jack_log ( "JackNetSlaveInterface::SendAvailableToMaster()" );
690 session_params_t host_params
;
694 if ( fSocket
.NewSocket() == SOCKET_ERROR
) {
695 jack_error ( "Fatal error : network unreachable - %s", StrError ( NET_ERROR_CODE
) );
696 return NET_SOCKET_ERROR
;
700 if ( fSocket
.Bind() == SOCKET_ERROR
) {
701 jack_error ( "Can't bind the socket : %s", StrError ( NET_ERROR_CODE
) );
702 return NET_SOCKET_ERROR
;
706 if ( fSocket
.SetTimeOut ( SLAVE_INIT_TIMEOUT
) == SOCKET_ERROR
)
707 jack_error ( "Can't set timeout : %s", StrError ( NET_ERROR_CODE
) );
710 if ( fSocket
.SetLocalLoop() == SOCKET_ERROR
)
711 jack_error ( "Can't disable multicast loop : %s", StrError ( NET_ERROR_CODE
) );
713 //send 'AVAILABLE' until 'SLAVE_SETUP' received
714 jack_info ( "Waiting for a master..." );
718 session_params_t net_params
;
719 memset(&net_params
, 0, sizeof ( session_params_t
));
720 SessionParamsHToN(&fParams
, &net_params
);
721 if ( fSocket
.SendTo ( &net_params
, sizeof ( session_params_t
), 0, fMulticastIP
) == SOCKET_ERROR
)
722 jack_error ( "Error in data send : %s", StrError ( NET_ERROR_CODE
) );
724 //filter incoming packets : don't exit while no error is detected
725 memset(&net_params
, 0, sizeof ( session_params_t
));
726 rx_bytes
= fSocket
.CatchHost ( &net_params
, sizeof ( session_params_t
), 0 );
727 SessionParamsNToH(&net_params
, &host_params
);
728 if ( ( rx_bytes
== SOCKET_ERROR
) && ( fSocket
.GetError() != NET_NO_DATA
) )
730 jack_error ( "Can't receive : %s", StrError ( NET_ERROR_CODE
) );
731 return NET_RECV_ERROR
;
734 while (strcmp(host_params
.fPacketType
, fParams
.fPacketType
) && (GetPacketType(&host_params
) != SLAVE_SETUP
) && (--try_count
> 0));
736 // Time out failure..
737 if (try_count
== 0) {
738 jack_error("Time out error in connect");
739 return NET_CONNECT_ERROR
;
742 //everything is OK, copy parameters
743 SessionParamsDisplay(&host_params
);
744 fParams
= host_params
;
747 if (fSocket
.Connect() == SOCKET_ERROR
) {
748 jack_error("Error in connect : %s", StrError(NET_ERROR_CODE
));
749 return NET_CONNECT_ERROR
;
751 return NET_CONNECTED
;
754 net_status_t
JackNetSlaveInterface::SendStartToMaster()
756 jack_log("JackNetSlaveInterface::SendStartToMaster");
758 //tell the master to start
759 session_params_t net_params
;
760 memset(&net_params
, 0, sizeof ( session_params_t
));
761 SetPacketType ( &fParams
, START_MASTER
);
762 SessionParamsHToN(&fParams
, &net_params
);
763 if (fSocket
.Send(&net_params
, sizeof(session_params_t
), 0) == SOCKET_ERROR
)
765 jack_error("Error in send : %s", StrError(NET_ERROR_CODE
));
766 return (fSocket
.GetError() == NET_CONN_ERROR
) ? NET_ERROR
: NET_SEND_ERROR
;
771 bool JackNetSlaveInterface::SetParams()
773 jack_log("JackNetSlaveInterface::SetParams");
775 JackNetInterface::SetParams();
777 fTxHeader
.fDataStream
= 'r';
778 fRxHeader
.fDataStream
= 's';
781 if (fParams
.fSendMidiChannels
)
782 fNetMidiCaptureBuffer
= new NetMidiBuffer(&fParams
, fParams
.fSendMidiChannels
, fTxData
);
784 if (fParams
.fReturnMidiChannels
)
785 fNetMidiPlaybackBuffer
= new NetMidiBuffer(&fParams
, fParams
.fReturnMidiChannels
, fRxData
);
790 if (fParams
.fSendAudioChannels
) {
792 switch (fParams
.fSampleEncoder
) {
794 case JackFloatEncoder
:
795 fNetAudioCaptureBuffer
= new NetFloatAudioBuffer(&fParams
, fParams
.fSendAudioChannels
, fRxData
);
799 fNetAudioCaptureBuffer
= new NetIntAudioBuffer(&fParams
, fParams
.fSendAudioChannels
, fRxData
);
802 case JackCeltEncoder
:
804 fNetAudioCaptureBuffer
= new NetCeltAudioBuffer(&fParams
, fParams
.fSendAudioChannels
, fRxData
, fParams
.fKBps
);
809 assert(fNetAudioCaptureBuffer
);
812 if (fParams
.fReturnAudioChannels
) {
814 switch (fParams
.fSampleEncoder
) {
816 case JackFloatEncoder
:
817 fNetAudioPlaybackBuffer
= new NetFloatAudioBuffer(&fParams
, fParams
.fReturnAudioChannels
, fTxData
);
821 fNetAudioPlaybackBuffer
= new NetIntAudioBuffer(&fParams
, fParams
.fReturnAudioChannels
, fTxData
);
824 case JackCeltEncoder
:
826 fNetAudioPlaybackBuffer
= new NetCeltAudioBuffer(&fParams
, fParams
.fReturnAudioChannels
, fTxData
, fParams
.fKBps
);
831 assert(fNetAudioPlaybackBuffer
);
834 } catch (exception
&) {
835 jack_error("NetAudioBuffer allocation error...");
839 //set the new buffer sizes
840 if (SetNetBufferSize() == SOCKET_ERROR
) {
841 jack_error ( "Can't set net buffer sizes : %s", StrError ( NET_ERROR_CODE
) );
848 FreeNetworkBuffers();
852 int JackNetSlaveInterface::Recv(size_t size
, int flags
)
854 int rx_bytes
= fSocket
.Recv(fRxBuffer
, size
, flags
);
856 if ( rx_bytes
== SOCKET_ERROR
)
858 net_error_t error
= fSocket
.GetError();
859 //no data isn't really an error in realtime processing, so just return 0
860 if ( error
== NET_NO_DATA
) {
861 jack_error ( "No data, is the master still running ?" );
862 //if a network error occurs, this exception will restart the driver
863 } else if ( error
== NET_CONN_ERROR
) {
864 jack_error ( "Connection lost." );
865 throw JackNetException();
867 jack_error ( "Fatal error in slave receive : %s", StrError ( NET_ERROR_CODE
) );
871 packet_header_t
* header
= reinterpret_cast<packet_header_t
*>(fRxBuffer
);
872 PacketHeaderNToH(header
, header
);
876 int JackNetSlaveInterface::Send(size_t size
, int flags
)
878 packet_header_t
* header
= reinterpret_cast<packet_header_t
*>(fTxBuffer
);
879 PacketHeaderHToN(header
, header
);
880 int tx_bytes
= fSocket
.Send ( fTxBuffer
, size
, flags
);
883 if ( tx_bytes
== SOCKET_ERROR
)
885 net_error_t error
= fSocket
.GetError();
886 //if a network error occurs, this exception will restart the driver
887 if ( error
== NET_CONN_ERROR
) {
888 jack_error ( "Connection lost." );
889 throw JackNetException();
891 jack_error ( "Fatal error in slave send : %s", StrError ( NET_ERROR_CODE
) );
897 int JackNetSlaveInterface::SyncRecv()
900 packet_header_t
* rx_head
= reinterpret_cast<packet_header_t
*> ( fRxBuffer
);
902 //receive sync (launch the cycle)
905 rx_bytes
= Recv(HEADER_SIZE
, 0);
906 //connection issue, send will detect it, so don't skip the cycle (return 0)
907 if ( rx_bytes
== SOCKET_ERROR
)
910 while ((strcmp(rx_head
->fPacketType
, "header") != 0) && (rx_head
->fDataType
!= 's'));
912 fRxHeader
.fIsLastPckt
= rx_head
->fIsLastPckt
;
916 int JackNetSlaveInterface::DataRecv()
919 uint recvd_midi_pckt
= 0;
920 packet_header_t
* rx_head
= reinterpret_cast<packet_header_t
*> ( fRxBuffer
);
922 while ( !fRxHeader
.fIsLastPckt
)
924 //how much data is queued on the rx buffer ?
925 rx_bytes
= Recv(HEADER_SIZE
, MSG_PEEK
);
927 //error here, problem with recv, just skip the cycle (return -1)
928 if ( rx_bytes
== SOCKET_ERROR
)
931 if ( rx_bytes
&& ( rx_head
->fDataStream
== 's' ) && ( rx_head
->fID
== fParams
.fID
) )
933 switch ( rx_head
->fDataType
)
936 rx_bytes
= Recv(rx_head
->fPacketSize
, 0);
937 fRxHeader
.fCycle
= rx_head
->fCycle
;
938 fRxHeader
.fIsLastPckt
= rx_head
->fIsLastPckt
;
939 fNetMidiCaptureBuffer
->RenderFromNetwork(rx_head
->fSubCycle
, rx_bytes
- HEADER_SIZE
);
940 // Last midi packet is received, so finish rendering...
941 if (++recvd_midi_pckt
== rx_head
->fNumPacket
)
942 fNetMidiCaptureBuffer
->RenderToJackPorts();
946 rx_bytes
= Recv(rx_head
->fPacketSize
, 0);
947 fRxHeader
.fCycle
= rx_head
->fCycle
;
948 fRxHeader
.fSubCycle
= rx_head
->fSubCycle
;
949 fRxHeader
.fIsLastPckt
= rx_head
->fIsLastPckt
;
950 fNetAudioCaptureBuffer
->RenderFromNetwork (rx_head
->fCycle
, rx_head
->fSubCycle
, rx_bytes
- HEADER_SIZE
);
951 // Last audio packet is received, so finish rendering...
952 if (fRxHeader
.fIsLastPckt
)
953 fNetAudioCaptureBuffer
->RenderToJackPorts();
957 jack_info ( "NetSlave : overloaded, skipping receive." );
958 // TODO : finish midi and audio rendering ?
959 fNetAudioCaptureBuffer
->RenderToJackPorts();
965 fRxHeader
.fCycle
= rx_head
->fCycle
;
969 int JackNetSlaveInterface::SyncSend()
972 if ( fParams
.fSlaveSyncMode
) {
973 fTxHeader
.fCycle
= fRxHeader
.fCycle
;
977 fTxHeader
.fSubCycle
= 0;
978 fTxHeader
.fDataType
= 's';
979 fTxHeader
.fIsLastPckt
= (fParams
.fReturnMidiChannels
== 0 && fParams
.fReturnAudioChannels
== 0) ? 1 : 0;
980 fTxHeader
.fPacketSize
= HEADER_SIZE
;
982 memcpy(fTxBuffer
, &fTxHeader
, HEADER_SIZE
);
983 return Send (fTxHeader
.fPacketSize
, 0);
986 int JackNetSlaveInterface::DataSend()
992 if (fParams
.fReturnMidiChannels
> 0)
994 //set global header fields and get the number of midi packets
995 fTxHeader
.fDataType
= 'm';
996 data_size
= fNetMidiPlaybackBuffer
->RenderFromJackPorts();
997 fTxHeader
.fNumPacket
= fNetMidiPlaybackBuffer
->GetNumPackets();
998 for ( subproc
= 0; subproc
< fTxHeader
.fNumPacket
; subproc
++ )
1000 fTxHeader
.fSubCycle
= subproc
;
1001 fTxHeader
.fIsLastPckt
= ((subproc
== (fTxHeader
.fNumPacket
- 1)) && !fParams
.fReturnAudioChannels
) ? 1 : 0;
1002 fTxHeader
.fPacketSize
= HEADER_SIZE
+ fNetMidiPlaybackBuffer
->RenderToNetwork(subproc
, data_size
);
1003 memcpy(fTxBuffer
, &fTxHeader
, HEADER_SIZE
);
1004 if (Send(fTxHeader
.fPacketSize
, 0) == SOCKET_ERROR
)
1005 return SOCKET_ERROR
;
1010 if ( fParams
.fReturnAudioChannels
> 0)
1012 fTxHeader
.fDataType
= 'a';
1013 data_size
= fNetAudioPlaybackBuffer
->RenderFromJackPorts();
1014 fTxHeader
.fNumPacket
= fNetAudioPlaybackBuffer
->GetNumPackets();
1015 for ( subproc
= 0; subproc
< fTxHeader
.fNumPacket
; subproc
++ )
1017 fTxHeader
.fSubCycle
= subproc
;
1018 fTxHeader
.fIsLastPckt
= (subproc
== (fTxHeader
.fNumPacket
- 1)) ? 1 : 0;
1019 fTxHeader
.fPacketSize
= HEADER_SIZE
+ fNetAudioPlaybackBuffer
->RenderToNetwork(subproc
, data_size
);
1020 memcpy(fTxBuffer
, &fTxHeader
, HEADER_SIZE
);
1021 if (Send(fTxHeader
.fPacketSize
, 0) == SOCKET_ERROR
)
1022 return SOCKET_ERROR
;
1028 //network sync------------------------------------------------------------------------
1029 void JackNetSlaveInterface::EncodeSyncPacket()
1031 //this method contains every step of sync packet informations coding
1032 //first of all, reset sync packet
1033 memset ( fTxData
, 0, PACKET_AVAILABLE_SIZE
);
1034 //then first step : transport
1035 if (fParams
.fTransportSync
) {
1036 EncodeTransportData();
1037 TransportDataHToN( &fReturnTransportData
, &fReturnTransportData
);
1039 memcpy ( fTxData
, &fReturnTransportData
, sizeof ( net_transport_data_t
) );
1045 void JackNetSlaveInterface::DecodeSyncPacket()
1047 //this method contains every step of sync packet informations decoding process
1049 if (fParams
.fTransportSync
) {
1050 //copy received transport data to transport data structure
1051 memcpy ( &fSendTransportData
, fRxData
, sizeof ( net_transport_data_t
) );
1052 TransportDataNToH( &fSendTransportData
, &fSendTransportData
);
1053 DecodeTransportData();