common/JackNetInterface.cpp

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2008 Romain Moret at 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 #include "JackNetInterface.h"
  21 #include "JackException.h"
  22 #include "JackPlatformPlug.h"
  23 #include <assert.h>
  24
  25 using namespace std;
  26
  27 /*
  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)
  31 */
  32
  33 namespace Jack
  34 {
  35     // JackNetInterface*******************************************
  36
  37     JackNetInterface::JackNetInterface() : fSocket()
  38     {
  39         fTxBuffer = NULL;
  40         fRxBuffer = NULL;
  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));
  47     }
  48
  49     JackNetInterface::JackNetInterface ( const char* multicast_ip, int port ) : fSocket ( multicast_ip, port )
  50     {
  51         strcpy(fMulticastIP, multicast_ip);
  52         fTxBuffer = NULL;
  53         fRxBuffer = NULL;
  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));
  60     }
  61
  62     JackNetInterface::JackNetInterface ( session_params_t& params, JackNetSocket& socket, const char* multicast_ip ) : fSocket ( socket )
  63     {
  64         fParams = params;
  65         strcpy(fMulticastIP, multicast_ip);
  66         fTxBuffer = NULL;
  67         fRxBuffer = NULL;
  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));
  74     }
  75
  76     JackNetInterface::~JackNetInterface()
  77     {
  78         jack_log ( "JackNetInterface::~JackNetInterface" );
  79
  80         fSocket.Close();
  81         delete[] fTxBuffer;
  82         delete[] fRxBuffer;
  83         delete fNetAudioCaptureBuffer;
  84         delete fNetAudioPlaybackBuffer;
  85         delete fNetMidiCaptureBuffer;
  86         delete fNetMidiPlaybackBuffer;
  87     }
  88
  89     void JackNetInterface::SetFramesPerPacket()
  90     {
  91         jack_log ( "JackNetInterface::SetFramesPerPacket" );
  92
  93         if (fParams.fSendAudioChannels == 0 && fParams.fReturnAudioChannels == 0) {
  94             fParams.fFramesPerPacket = fParams.fPeriodSize;
  95         } else {
  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;
  99         }
 100     }
 101
 102     int JackNetInterface::SetNetBufferSize()
 103     {
 104         jack_log ( "JackNetInterface::SetNetBufferSize" );
 105
 106         float audio_size, midi_size;
 107         int bufsize;
 108         //audio
 109         audio_size = fParams.fMtu * ( fParams.fPeriodSize / fParams.fFramesPerPacket );
 110         //midi
 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);
 115
 116         //tx buffer
 117         if ( fSocket.SetOption ( SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof ( bufsize ) ) == SOCKET_ERROR )
 118             return SOCKET_ERROR;
 119
 120         //rx buffer
 121         if ( fSocket.SetOption ( SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof ( bufsize ) ) == SOCKET_ERROR )
 122             return SOCKET_ERROR;
 123
 124         return 0;
 125     }
 126
 127     int JackNetInterface::GetNMidiPckt()
 128     {
 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 ) ) )
 132             return 1;
 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 ) ) )
 136             return ++npckt;
 137         return npckt;
 138     }
 139
 140     bool JackNetInterface::IsNextPacket()
 141     {
 142         packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );
 143         //ignore first cycle
 144         if ( fRxHeader.fCycle <= 1 ) {
 145             return true;
 146         }
 147         //same PcktID (cycle), next SubPcktID (subcycle)
 148         if ( ( fRxHeader.fSubCycle < ( fNSubProcess - 1 ) ) && ( rx_head->fCycle == fRxHeader.fCycle ) && ( rx_head->fSubCycle == ( fRxHeader.fSubCycle + 1 ) ) ) {
 149              return true;
 150         }
 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 ) ) {
 153             return true;
 154         }
 155         //else, packet(s) missing, return false
 156         return false;
 157     }
 158
 159     void JackNetInterface::SetParams()
 160     {
 161         //number of audio subcycles (packets)
 162         fNSubProcess = fParams.fPeriodSize / fParams.fFramesPerPacket;
 163
 164         //payload size
 165         fPayloadSize = fParams.fMtu - sizeof ( packet_header_t );
 166
 167         //TX header init
 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;
 175
 176         //RX header init
 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;
 184
 185         //network buffers
 186         fTxBuffer = new char[fParams.fMtu];
 187         fRxBuffer = new char[fParams.fMtu];
 188         assert ( fTxBuffer );
 189         assert ( fRxBuffer );
 190
 191         //net audio/midi buffers'addresses
 192         fTxData = fTxBuffer + sizeof ( packet_header_t );
 193         fRxData = fRxBuffer + sizeof ( packet_header_t );
 194     }
 195
 196     // JackNetMasterInterface ************************************************************************************
 197
 198     bool JackNetMasterInterface::Init()
 199     {
 200         jack_log ( "JackNetMasterInterface::Init, ID %u.", fParams.fID );
 201
 202         session_params_t host_params;
 203         uint attempt = 0;
 204         int rx_bytes = 0;
 205
 206         //socket
 207         if ( fSocket.NewSocket() == SOCKET_ERROR ) {
 208             jack_error ( "Can't create socket : %s", StrError ( NET_ERROR_CODE ) );
 209             return false;
 210         }
 211
 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 ) );
 215
 216         //connect
 217         if ( fSocket.Connect() == SOCKET_ERROR ) {
 218             jack_error ( "Can't connect : %s", StrError ( NET_ERROR_CODE ) );
 219             return false;
 220         }
 221
 222         //set the number of complete audio frames we can put in a packet
 223         SetFramesPerPacket();
 224
 225         //send 'SLAVE_SETUP' until 'START_MASTER' received
 226         jack_info ( "Sending parameters to %s ...", fParams.fSlaveNetName );
 227         do
 228         {
 229             session_params_t net_params;
 230             SetPacketType ( &fParams, SLAVE_SETUP );
 231             SessionParamsHToN(&fParams, &net_params);
 232
 233             if ( fSocket.Send ( &net_params, sizeof ( session_params_t ), 0 ) == SOCKET_ERROR )
 234                 jack_error ( "Error in send : ", StrError ( NET_ERROR_CODE ) );
 235
 236             memset(&net_params, 0, sizeof ( session_params_t ));
 237             if ( ( ( rx_bytes = fSocket.Recv ( &net_params, sizeof ( session_params_t ), 0 ) ) == SOCKET_ERROR ) && ( fSocket.GetError() != NET_NO_DATA ) )
 238             {
 239                 jack_error ( "Problem with network." );
 240                 return false;
 241             }
 242
 243             SessionParamsNToH(&net_params, &host_params);
 244         }
 245         while ( ( GetPacketType ( &host_params ) != START_MASTER ) && ( ++attempt < SLAVE_SETUP_RETRY ) );
 246         if ( attempt == SLAVE_SETUP_RETRY ) {
 247             jack_error ( "Slave doesn't respond, exiting." );
 248             return false;
 249         }
 250
 251         //set the new timeout for the socket
 252         if ( SetRxTimeout() == SOCKET_ERROR ) {
 253             jack_error ( "Can't set rx timeout : %s", StrError ( NET_ERROR_CODE ) );
 254             return false;
 255         }
 256
 257         //set the new rx buffer size
 258         if ( SetNetBufferSize() == SOCKET_ERROR ) {
 259             jack_error ( "Can't set net buffer sizes : %s", StrError ( NET_ERROR_CODE ) );
 260             return false;
 261         }
 262
 263         return true;
 264     }
 265
 266     int JackNetMasterInterface::SetRxTimeout()
 267     {
 268         jack_log ( "JackNetMasterInterface::SetRxTimeout" );
 269
 270         float time = 0;
 271         //slow or normal mode, short timeout on recv (2 audio subcycles)
 272         if ( ( fParams.fNetworkMode == 's' ) || ( fParams.fNetworkMode == 'n' ) )
 273             time = 2000000.f * ( static_cast<float> ( fParams.fFramesPerPacket ) / static_cast<float> ( fParams.fSampleRate ) );
 274         //fast mode, wait for 75% of the entire cycle duration
 275         else if ( fParams.fNetworkMode == 'f' )
 276             time = 750000.f * ( static_cast<float> ( fParams.fPeriodSize ) / static_cast<float> ( fParams.fSampleRate ) );
 277         return fSocket.SetTimeOut ( static_cast<int> ( time ) );
 278     }
 279
 280     void JackNetMasterInterface::SetParams()
 281     {
 282         jack_log ( "JackNetMasterInterface::SetParams" );
 283
 284         JackNetInterface::SetParams();
 285
 286         fTxHeader.fDataStream = 's';
 287         fRxHeader.fDataStream = 'r';
 288
 289         //midi net buffers
 290         fNetMidiCaptureBuffer = new NetMidiBuffer ( &fParams, fParams.fSendMidiChannels, fTxData );
 291         fNetMidiPlaybackBuffer = new NetMidiBuffer ( &fParams, fParams.fReturnMidiChannels, fRxData );
 292         assert ( fNetMidiCaptureBuffer );
 293         assert ( fNetMidiPlaybackBuffer );
 294
 295         //audio net buffers
 296         fNetAudioCaptureBuffer = new NetAudioBuffer ( &fParams, fParams.fSendAudioChannels, fTxData );
 297         fNetAudioPlaybackBuffer = new NetAudioBuffer ( &fParams, fParams.fReturnAudioChannels, fRxData );
 298         assert ( fNetAudioCaptureBuffer );
 299         assert ( fNetAudioPlaybackBuffer );
 300
 301         //audio netbuffer length
 302         fAudioTxLen = sizeof ( packet_header_t ) + fNetAudioCaptureBuffer->GetSize();
 303         fAudioRxLen = sizeof ( packet_header_t ) + fNetAudioPlaybackBuffer->GetSize();
 304     }
 305
 306     void JackNetMasterInterface::Exit()
 307     {
 308         jack_log ( "JackNetMasterInterface::Exit, ID %u", fParams.fID );
 309
 310         //stop process
 311         fRunning = false;
 312
 313         //send a 'multicast euthanasia request' - new socket is required on macosx
 314         jack_info ( "Exiting '%s'", fParams.fName );
 315         SetPacketType ( &fParams, KILL_MASTER );
 316         JackNetSocket mcast_socket ( fMulticastIP, fSocket.GetPort() );
 317
 318         session_params_t net_params;
 319         SessionParamsHToN(&fParams, &net_params);
 320
 321         if ( mcast_socket.NewSocket() == SOCKET_ERROR )
 322             jack_error ( "Can't create socket : %s", StrError ( NET_ERROR_CODE ) );
 323         if ( mcast_socket.SendTo ( &net_params, sizeof ( session_params_t ), 0, fMulticastIP ) == SOCKET_ERROR )
 324             jack_error ( "Can't send suicide request : %s", StrError ( NET_ERROR_CODE ) );
 325
 326         mcast_socket.Close();
 327     }
 328
 329     int JackNetMasterInterface::Recv ( size_t size, int flags )
 330     {
 331         int rx_bytes;
 332         if ( ( ( rx_bytes = fSocket.Recv ( fRxBuffer, size, flags ) ) == SOCKET_ERROR ) && fRunning )
 333         {
 334             net_error_t error = fSocket.GetError();
 335             //no data isn't really a network error, so just return 0 avalaible read bytes
 336             if ( error == NET_NO_DATA )
 337                 return 0;
 338             else if ( error == NET_CONN_ERROR )
 339             {
 340                 //fatal connection issue, exit
 341                 jack_error ( "'%s' : %s, exiting.", fParams.fName, StrError ( NET_ERROR_CODE ) );
 342                 //ask to the manager to properly remove the master
 343                 Exit();
 344
 345                 // UGLY temporary way to be sure the thread does not call code possibly causing a deadlock in JackEngine.
 346                 ThreadExit();
 347             }
 348             else
 349                 jack_error ( "Error in master receive : %s", StrError ( NET_ERROR_CODE ) );
 350         }
 351
 352         packet_header_t* header = reinterpret_cast<packet_header_t*>(fRxBuffer);
 353         PacketHeaderNToH(header, header);
 354         return rx_bytes;
 355     }
 356
 357     int JackNetMasterInterface::Send ( size_t size, int flags )
 358     {
 359         int tx_bytes;
 360         packet_header_t* header = reinterpret_cast<packet_header_t*>(fTxBuffer);
 361         PacketHeaderHToN(header, header);
 362
 363         if ( ( ( tx_bytes = fSocket.Send ( fTxBuffer, size, flags ) ) == SOCKET_ERROR ) && fRunning )
 364         {
 365             net_error_t error = fSocket.GetError();
 366             if ( error == NET_CONN_ERROR )
 367             {
 368                 //fatal connection issue, exit
 369                 jack_error ( "'%s' : %s, exiting.", fParams.fName, StrError ( NET_ERROR_CODE ) );
 370                 Exit();
 371
 372                 // UGLY temporary way to be sure the thread does not call code possibly causing a deadlock in JackEngine.
 373                 ThreadExit();
 374             }
 375             else
 376                 jack_error ( "Error in master send : %s", StrError ( NET_ERROR_CODE ) );
 377         }
 378         return tx_bytes;
 379     }
 380
 381     bool JackNetMasterInterface::IsSynched()
 382     {
 383         if (fParams.fNetworkMode == 's') {
 384             return (fCycleOffset < 3);
 385         } else {
 386             return true;
 387         }
 388     }
 389
 390     int JackNetMasterInterface::SyncSend()
 391     {
 392         fTxHeader.fCycle++;
 393         fTxHeader.fSubCycle = 0;
 394         fTxHeader.fDataType = 's';
 395         fTxHeader.fIsLastPckt = ( fParams.fSendMidiChannels == 0 && fParams.fSendAudioChannels == 0) ?  1 : 0;
 396         fTxHeader.fPacketSize = fParams.fMtu;
 397         memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
 398         return Send ( fTxHeader.fPacketSize, 0 );
 399     }
 400
 401     int JackNetMasterInterface::DataSend()
 402     {
 403         uint subproc;
 404         //midi
 405         if ( fParams.fSendMidiChannels > 0)
 406         {
 407             //set global header fields and get the number of midi packets
 408             fTxHeader.fDataType = 'm';
 409             fTxHeader.fMidiDataSize = fNetMidiCaptureBuffer->RenderFromJackPorts();
 410             fTxHeader.fNMidiPckt = GetNMidiPckt();
 411             for ( subproc = 0; subproc < fTxHeader.fNMidiPckt; subproc++ )
 412             {
 413                 fTxHeader.fSubCycle = subproc;
 414                 fTxHeader.fIsLastPckt = ( ( subproc == ( fTxHeader.fNMidiPckt - 1 ) ) && (fParams.fSendAudioChannels == 0)) ? 1 : 0;
 415                 fTxHeader.fPacketSize = sizeof ( packet_header_t ) + fNetMidiCaptureBuffer->RenderToNetwork ( subproc, fTxHeader.fMidiDataSize );
 416                 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
 417                 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR )
 418                     return SOCKET_ERROR;
 419             }
 420         }
 421
 422         //audio
 423         if ( fParams.fSendAudioChannels > 0)
 424         {
 425             fTxHeader.fDataType = 'a';
 426             fTxHeader.fMidiDataSize = 0;
 427             fTxHeader.fNMidiPckt = 0;
 428             for ( subproc = 0; subproc < fNSubProcess; subproc++ )
 429             {
 430                 fTxHeader.fSubCycle = subproc;
 431                 fTxHeader.fIsLastPckt = ( subproc == ( fNSubProcess - 1 ) ) ? 1 : 0;
 432                 fTxHeader.fPacketSize = fAudioTxLen;
 433                 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
 434                 fNetAudioCaptureBuffer->RenderFromJackPorts ( subproc );
 435                 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR )
 436                     return SOCKET_ERROR;
 437             }
 438         }
 439
 440         return 0;
 441     }
 442
 443     int JackNetMasterInterface::SyncRecv()
 444     {
 445         packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );
 446         int rx_bytes = Recv ( fParams.fMtu, MSG_PEEK );
 447
 448         if ( ( rx_bytes == 0 ) || ( rx_bytes == SOCKET_ERROR ) )
 449             return rx_bytes;
 450
 451         fCycleOffset = fTxHeader.fCycle - rx_head->fCycle;
 452
 453         switch ( fParams.fNetworkMode )
 454         {
 455             case 's' :
 456                 //slow mode : allow to use full bandwidth and heavy process on the slave
 457                 //  - extra latency is set to two cycles, one cycle for send/receive operations + one cycle for heavy process on the slave
 458                 //  - if the network is two fast, just wait the next cycle, this mode allows a shorter cycle duration for the master
 459                 //  - this mode will skip the two first cycles, thus it lets time for data to be processed and queued on the socket rx buffer
 460                 //the slow mode is the safest mode because it wait twice the bandwidth relative time (send/return + process)
 461                 if (fCycleOffset < 2)
 462                      return 0;
 463                 else
 464                     rx_bytes = Recv ( rx_head->fPacketSize, 0 );
 465
 466                 if (fCycleOffset > 2) {
 467                     jack_info("Warning : '%s' runs in slow network mode, but data received too late (%d cycle(s) offset)", fParams.fName, fCycleOffset);
 468                 }
 469                 break;
 470
 471             case 'n' :
 472                 //normal use of the network :
 473                 //  - extra latency is set to one cycle, what is the time needed to receive streams using full network bandwidth
 474                 //  - if the network is too fast, just wait the next cycle, the benefit here is the master's cycle is shorter
 475                 //  - indeed, data is supposed to be on the network rx buffer, so we don't have to wait for it
 476                 if (fCycleOffset < 1)
 477                     return 0;
 478                 else
 479                     rx_bytes = Recv ( rx_head->fPacketSize, 0 );
 480
 481                 if (fCycleOffset != 1)
 482                     jack_info("'%s' can't run in normal network mode, data received too late (%d cycle(s) offset)", fParams.fName, fCycleOffset);
 483                 break;
 484
 485             case 'f' :
 486                 //fast mode suppose the network bandwith is larger than required for the transmission (only a few channels for example)
 487                 //    - packets can be quickly received, quickly is here relative to the cycle duration
 488                 //    - here, receive data, we can't keep it queued on the rx buffer,
 489                 //    - but if there is a cycle offset, tell the user, that means we're not in fast mode anymore, network is too slow
 490                 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
 491
 492                 if (fCycleOffset != 0)
 493                     jack_info("'%s' can't run in fast network mode, data received too late (%d cycle(s) offset)", fParams.fName, fCycleOffset);
 494                 break;
 495         }
 496
 497         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
 498         return rx_bytes;
 499     }
 500
 501     int JackNetMasterInterface::DataRecv()
 502     {
 503         int rx_bytes = 0;
 504         uint jumpcnt = 0;
 505         uint recvd_midi_pckt = 0;
 506         uint recvd_audio_pckt = 0;
 507         packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );
 508
 509         while ( !fRxHeader.fIsLastPckt )
 510         {
 511             //how much data is queued on the rx buffer ?
 512             rx_bytes = Recv ( fParams.fMtu, MSG_PEEK );
 513
 514             if ( rx_bytes == SOCKET_ERROR )
 515                 return rx_bytes;
 516             //if no data
 517             if ( ( rx_bytes == 0 ) && ( ++jumpcnt == fNSubProcess ) )
 518             {
 519                 jack_error ( "No data from %s...", fParams.fName );
 520                 jumpcnt = 0;
 521             }
 522             //else if data is valid,
 523             if ( rx_bytes && ( rx_head->fDataStream == 'r' ) && ( rx_head->fID == fParams.fID ) )
 524             {
 525                 //read data
 526                 switch ( rx_head->fDataType )
 527                 {
 528                     case 'm':   //midi
 529                         rx_bytes = Recv ( rx_head->fPacketSize, 0 );
 530                         fRxHeader.fCycle = rx_head->fCycle;
 531                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
 532                         fNetMidiPlaybackBuffer->RenderFromNetwork ( rx_head->fSubCycle, rx_bytes - sizeof ( packet_header_t ) );
 533                         if ( ++recvd_midi_pckt == rx_head->fNMidiPckt )
 534                             fNetMidiPlaybackBuffer->RenderToJackPorts();
 535                         jumpcnt = 0;
 536                         break;
 537
 538                     case 'a':   //audio
 539                         rx_bytes = Recv ( rx_head->fPacketSize, 0 );
 540                         // SL: 25/01/09
 541                         // if ( !IsNextPacket() )
 542                         //    jack_error ( "Packet(s) missing from '%s'...", fParams.fName );
 543                         if (recvd_audio_pckt++ != rx_head->fSubCycle) {
 544                             jack_error("Packet(s) missing from '%s'...", fParams.fSlaveNetName);
 545                         }
 546                         fRxHeader.fCycle = rx_head->fCycle;
 547                         fRxHeader.fSubCycle = rx_head->fSubCycle;
 548                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
 549                         fNetAudioPlaybackBuffer->RenderToJackPorts ( rx_head->fSubCycle );
 550                         jumpcnt = 0;
 551                         break;
 552
 553                     case 's':   //sync
 554                         /* SL: 25/01/09
 555                         if ( rx_head->fCycle == fTxHeader.fCycle )
 556                             return 0;
 557                         */
 558                         jack_info("NetMaster : overloaded, skipping receive from '%s'", fParams.fName);
 559                         return 0;
 560                 }
 561             }
 562         }
 563         return rx_bytes;
 564     }
 565
 566     void JackNetMasterInterface::EncodeSyncPacket()
 567     {
 568         //this method contains every step of sync packet informations coding
 569         //first of all, reset sync packet
 570         memset ( fTxData, 0, fPayloadSize );
 571
 572         //then, first step : transport
 573         if (fParams.fTransportSync) {
 574             EncodeTransportData();
 575             TransportDataHToN( &fSendTransportData,  &fSendTransportData);
 576             //copy to TxBuffer
 577             memcpy ( fTxData, &fSendTransportData, sizeof ( net_transport_data_t ) );
 578         }
 579         //then others (freewheel etc.)
 580         //...
 581     }
 582
 583     void JackNetMasterInterface::DecodeSyncPacket()
 584     {
 585         //this method contains every step of sync packet informations decoding process
 586         //first : transport
 587         if (fParams.fTransportSync) {
 588             //copy received transport data to transport data structure
 589             memcpy ( &fReturnTransportData, fRxData, sizeof ( net_transport_data_t ) );
 590             TransportDataNToH( &fReturnTransportData,  &fReturnTransportData);
 591             DecodeTransportData();
 592         }
 593         //then others
 594         //...
 595     }
 596
 597 // JackNetSlaveInterface ************************************************************************************************
 598
 599     uint JackNetSlaveInterface::fSlaveCounter = 0;
 600
 601     bool JackNetSlaveInterface::Init()
 602     {
 603         jack_log ( "JackNetSlaveInterface::Init()" );
 604
 605         //set the parameters to send
 606         strcpy ( fParams.fPacketType, "params" );
 607         fParams.fProtocolVersion = SLAVE_PROTOCOL;
 608         SetPacketType ( &fParams, SLAVE_AVAILABLE );
 609
 610         //init loop : get a master and start, do it until connection is ok
 611         net_status_t status;
 612         do
 613         {
 614             //first, get a master, do it until a valid connection is running
 615             do
 616             {
 617                 status = SendAvailableToMaster();
 618                 if ( status == NET_SOCKET_ERROR )
 619                     return false;
 620             }
 621             while ( status != NET_CONNECTED );
 622
 623             //then tell the master we are ready
 624             jack_info ( "Initializing connection with %s...", fParams.fMasterNetName );
 625             status = SendStartToMaster();
 626             if ( status == NET_ERROR )
 627                 return false;
 628         }
 629         while ( status != NET_ROLLING );
 630
 631         return true;
 632     }
 633
 634     // Separate the connection protocol into two separated step
 635
 636     bool JackNetSlaveInterface::InitConnection()
 637     {
 638         jack_log ( "JackNetSlaveInterface::InitConnection()" );
 639
 640         //set the parameters to send
 641         strcpy (fParams.fPacketType, "params");
 642         fParams.fProtocolVersion = SLAVE_PROTOCOL;
 643         SetPacketType (&fParams, SLAVE_AVAILABLE);
 644
 645         net_status_t status;
 646         do
 647         {
 648             //get a master
 649             status = SendAvailableToMaster();
 650             if (status == NET_SOCKET_ERROR)
 651                 return false;
 652         }
 653         while (status != NET_CONNECTED);
 654
 655         return true;
 656     }
 657
 658     bool JackNetSlaveInterface::InitRendering()
 659     {
 660         jack_log("JackNetSlaveInterface::InitRendering()");
 661
 662         net_status_t status;
 663         do
 664         {
 665             //then tell the master we are ready
 666             jack_info("Initializing connection with %s...", fParams.fMasterNetName);
 667             status = SendStartToMaster();
 668             if (status == NET_ERROR)
 669                 return false;
 670         }
 671         while (status != NET_ROLLING);
 672
 673         return true;
 674     }
 675
 676     net_status_t JackNetSlaveInterface::SendAvailableToMaster()
 677     {
 678         jack_log ( "JackNetSlaveInterface::SendAvailableToMaster()" );
 679         //utility
 680         session_params_t host_params;
 681         int rx_bytes = 0;
 682
 683         //socket
 684         if ( fSocket.NewSocket() == SOCKET_ERROR ) {
 685             jack_error ( "Fatal error : network unreachable - %s", StrError ( NET_ERROR_CODE ) );
 686             return NET_SOCKET_ERROR;
 687         }
 688
 689         //bind the socket
 690         if ( fSocket.Bind() == SOCKET_ERROR ) {
 691             jack_error ( "Can't bind the socket : %s", StrError ( NET_ERROR_CODE ) );
 692             return NET_SOCKET_ERROR;
 693         }
 694
 695         //timeout on receive
 696         if ( fSocket.SetTimeOut ( SLAVE_INIT_TIMEOUT ) == SOCKET_ERROR )
 697             jack_error ( "Can't set timeout : %s", StrError ( NET_ERROR_CODE ) );
 698
 699         //disable local loop
 700         if ( fSocket.SetLocalLoop() == SOCKET_ERROR )
 701             jack_error ( "Can't disable multicast loop : %s", StrError ( NET_ERROR_CODE ) );
 702
 703         //send 'AVAILABLE' until 'SLAVE_SETUP' received
 704         jack_info ( "Waiting for a master..." );
 705         do
 706         {
 707             //send 'available'
 708             session_params_t net_params;
 709             SessionParamsHToN(&fParams, &net_params);
 710             if ( fSocket.SendTo ( &net_params, sizeof ( session_params_t ), 0, fMulticastIP ) == SOCKET_ERROR )
 711                 jack_error ( "Error in data send : %s", StrError ( NET_ERROR_CODE ) );
 712
 713             //filter incoming packets : don't exit while no error is detected
 714             memset(&net_params, 0, sizeof ( session_params_t ));
 715             rx_bytes = fSocket.CatchHost ( &net_params, sizeof ( session_params_t ), 0 );
 716             SessionParamsNToH(&net_params, &host_params);
 717             if ( ( rx_bytes == SOCKET_ERROR ) && ( fSocket.GetError() != NET_NO_DATA ) )
 718             {
 719                 jack_error ( "Can't receive : %s", StrError ( NET_ERROR_CODE ) );
 720                 return NET_RECV_ERROR;
 721             }
 722         }
 723         while ( strcmp ( host_params.fPacketType, fParams.fPacketType )  && ( GetPacketType ( &host_params ) != SLAVE_SETUP ) );
 724
 725         //everything is OK, copy parameters
 726         fParams = host_params;
 727
 728         //set the new buffer sizes
 729         if ( SetNetBufferSize() == SOCKET_ERROR ) {
 730             jack_error ( "Can't set net buffer sizes : %s", StrError ( NET_ERROR_CODE ) );
 731              return NET_SOCKET_ERROR;
 732         }
 733
 734         //connect the socket
 735         if ( fSocket.Connect() == SOCKET_ERROR ) {
 736             jack_error ( "Error in connect : %s", StrError ( NET_ERROR_CODE ) );
 737             return NET_CONNECT_ERROR;
 738         }
 739
 740         return NET_CONNECTED;
 741     }
 742
 743     net_status_t JackNetSlaveInterface::SendStartToMaster()
 744     {
 745         jack_log ( "JackNetSlaveInterface::SendStartToMaster" );
 746
 747         //tell the master to start
 748         session_params_t net_params;
 749         SetPacketType ( &fParams, START_MASTER );
 750         SessionParamsHToN(&fParams, &net_params);
 751         if ( fSocket.Send ( &net_params, sizeof ( session_params_t ), 0 ) == SOCKET_ERROR )
 752         {
 753             jack_error ( "Error in send : %s", StrError ( NET_ERROR_CODE ) );
 754             return ( fSocket.GetError() == NET_CONN_ERROR ) ? NET_ERROR : NET_SEND_ERROR;
 755         }
 756         return NET_ROLLING;
 757     }
 758
 759     void JackNetSlaveInterface::SetParams()
 760     {
 761         jack_log ( "JackNetSlaveInterface::SetParams" );
 762
 763         JackNetInterface::SetParams();
 764
 765         fTxHeader.fDataStream = 'r';
 766         fRxHeader.fDataStream = 's';
 767
 768         //midi net buffers
 769         fNetMidiCaptureBuffer = new NetMidiBuffer ( &fParams, fParams.fSendMidiChannels, fRxData );
 770         fNetMidiPlaybackBuffer = new NetMidiBuffer ( &fParams, fParams.fReturnMidiChannels, fTxData );
 771
 772         //audio net buffers
 773         fNetAudioCaptureBuffer = new NetAudioBuffer ( &fParams, fParams.fSendAudioChannels, fRxData );
 774         fNetAudioPlaybackBuffer = new NetAudioBuffer ( &fParams, fParams.fReturnAudioChannels, fTxData );
 775
 776         //audio netbuffer length
 777         fAudioTxLen = sizeof ( packet_header_t ) + fNetAudioPlaybackBuffer->GetSize();
 778         fAudioRxLen = sizeof ( packet_header_t ) + fNetAudioCaptureBuffer->GetSize();
 779     }
 780
 781     int JackNetSlaveInterface::Recv ( size_t size, int flags )
 782     {
 783         int rx_bytes = fSocket.Recv ( fRxBuffer, size, flags );
 784         //handle errors
 785         if ( rx_bytes == SOCKET_ERROR )
 786         {
 787             net_error_t error = fSocket.GetError();
 788             //no data isn't really an error in realtime processing, so just return 0
 789             if ( error == NET_NO_DATA )
 790                 jack_error ( "No data, is the master still running ?" );
 791             //if a network error occurs, this exception will restart the driver
 792             else if ( error == NET_CONN_ERROR )
 793             {
 794                 jack_error ( "Connection lost." );
 795                 throw JackNetException();
 796             }
 797             else
 798                 jack_error ( "Fatal error in slave receive : %s", StrError ( NET_ERROR_CODE ) );
 799         }
 800
 801         packet_header_t* header = reinterpret_cast<packet_header_t*>(fRxBuffer);
 802         PacketHeaderNToH(header, header);
 803         return rx_bytes;
 804     }
 805
 806     int JackNetSlaveInterface::Send ( size_t size, int flags )
 807     {
 808         packet_header_t* header = reinterpret_cast<packet_header_t*>(fTxBuffer);
 809         PacketHeaderHToN(header, header);
 810         int tx_bytes = fSocket.Send ( fTxBuffer, size, flags );
 811
 812         //handle errors
 813         if ( tx_bytes == SOCKET_ERROR )
 814         {
 815             net_error_t error = fSocket.GetError();
 816             //if a network error occurs, this exception will restart the driver
 817             if ( error == NET_CONN_ERROR )
 818             {
 819                 jack_error ( "Connection lost." );
 820                 throw JackNetException();
 821             }
 822             else
 823                 jack_error ( "Fatal error in slave send : %s", StrError ( NET_ERROR_CODE ) );
 824         }
 825         return tx_bytes;
 826     }
 827
 828     int JackNetSlaveInterface::SyncRecv()
 829     {
 830         int rx_bytes = 0;
 831         packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );
 832         //receive sync (launch the cycle)
 833         do
 834         {
 835             rx_bytes = Recv ( fParams.fMtu, 0 );
 836             //connection issue, send will detect it, so don't skip the cycle (return 0)
 837             if ( rx_bytes == SOCKET_ERROR )
 838                 return rx_bytes;
 839         }
 840         while ((strcmp(rx_head->fPacketType, "header") != 0) && (rx_head->fDataType != 's'));
 841
 842         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
 843         return rx_bytes;
 844     }
 845
 846     int JackNetSlaveInterface::DataRecv()
 847     {
 848         uint recvd_midi_pckt = 0;
 849         uint recvd_audio_pckt = 0;
 850         int rx_bytes = 0;
 851         packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );
 852
 853         while ( !fRxHeader.fIsLastPckt )
 854         {
 855             rx_bytes = Recv ( fParams.fMtu, MSG_PEEK );
 856             //error here, problem with recv, just skip the cycle (return -1)
 857
 858             if ( rx_bytes == SOCKET_ERROR )
 859                 return rx_bytes;
 860             if ( rx_bytes && ( rx_head->fDataStream == 's' ) && ( rx_head->fID == fParams.fID ) )
 861             {
 862                 switch ( rx_head->fDataType )
 863                 {
 864                     case 'm':   //midi
 865                         rx_bytes = Recv ( rx_head->fPacketSize, 0 );
 866                         fRxHeader.fCycle = rx_head->fCycle;
 867                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
 868                         fNetMidiCaptureBuffer->RenderFromNetwork ( rx_head->fSubCycle, rx_bytes - sizeof ( packet_header_t ) );
 869                         if ( ++recvd_midi_pckt == rx_head->fNMidiPckt )
 870                             fNetMidiCaptureBuffer->RenderToJackPorts();
 871                         break;
 872
 873                     case 'a':   //audio
 874                         rx_bytes = Recv ( rx_head->fPacketSize, 0 );
 875                         //SL: 25/01/09
 876                         // if ( !IsNextPacket() )
 877                         //    jack_error ( "Packet(s) missing..." );
 878                         if (recvd_audio_pckt++ != rx_head->fSubCycle) {
 879                             jack_error("Packet(s) missing from '%s'...", fParams.fMasterNetName);
 880                         }
 881                         fRxHeader.fCycle = rx_head->fCycle;
 882                         fRxHeader.fSubCycle = rx_head->fSubCycle;
 883                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
 884                         fNetAudioCaptureBuffer->RenderToJackPorts ( rx_head->fSubCycle );
 885                         break;
 886
 887                     case 's':   //sync
 888                         jack_info ( "NetSlave : overloaded, skipping receive." );
 889                         return 0;
 890                 }
 891             }
 892         }
 893         fRxHeader.fCycle = rx_head->fCycle;
 894         return 0;
 895     }
 896
 897     int JackNetSlaveInterface::SyncSend()
 898     {
 899         //tx header
 900         if ( fParams.fSlaveSyncMode )
 901             fTxHeader.fCycle = fRxHeader.fCycle;
 902         else
 903             fTxHeader.fCycle++;
 904         fTxHeader.fSubCycle = 0;
 905         fTxHeader.fDataType = 's';
 906         fTxHeader.fIsLastPckt = ( fParams.fReturnMidiChannels == 0 && fParams.fReturnAudioChannels == 0) ?  1 : 0;
 907         fTxHeader.fPacketSize = fParams.fMtu;
 908         memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
 909         return Send ( fTxHeader.fPacketSize, 0 );
 910     }
 911
 912     int JackNetSlaveInterface::DataSend()
 913     {
 914         uint subproc;
 915
 916         //midi
 917         if ( fParams.fReturnMidiChannels > 0)
 918         {
 919             fTxHeader.fDataType = 'm';
 920             fTxHeader.fMidiDataSize = fNetMidiPlaybackBuffer->RenderFromJackPorts();
 921             fTxHeader.fNMidiPckt = GetNMidiPckt();
 922             for ( subproc = 0; subproc < fTxHeader.fNMidiPckt; subproc++ )
 923             {
 924                 fTxHeader.fSubCycle = subproc;
 925                 fTxHeader.fIsLastPckt = ( ( subproc == ( fTxHeader.fNMidiPckt - 1 ) ) && !fParams.fReturnAudioChannels ) ? 1 : 0;
 926                 fTxHeader.fPacketSize = sizeof ( packet_header_t ) + fNetMidiPlaybackBuffer->RenderToNetwork ( subproc, fTxHeader.fMidiDataSize );
 927                 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
 928                 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR )
 929                     return SOCKET_ERROR;
 930             }
 931         }
 932
 933         //audio
 934         if ( fParams.fReturnAudioChannels > 0)
 935         {
 936             fTxHeader.fDataType = 'a';
 937             fTxHeader.fMidiDataSize = 0;
 938             fTxHeader.fNMidiPckt = 0;
 939             for ( subproc = 0; subproc < fNSubProcess; subproc++ )
 940             {
 941                 fTxHeader.fSubCycle = subproc;
 942                 fTxHeader.fIsLastPckt = ( subproc == ( fNSubProcess - 1 ) ) ? 1 : 0;
 943                 fTxHeader.fPacketSize = fAudioTxLen;
 944                 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
 945                 fNetAudioPlaybackBuffer->RenderFromJackPorts ( subproc );
 946                 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR )
 947                     return SOCKET_ERROR;
 948             }
 949         }
 950         return 0;
 951     }
 952
 953     //network sync------------------------------------------------------------------------
 954     void JackNetSlaveInterface::EncodeSyncPacket()
 955     {
 956         //this method contains every step of sync packet informations coding
 957         //first of all, reset sync packet
 958         memset ( fTxData, 0, fPayloadSize );
 959         //then first step : transport
 960         if (fParams.fTransportSync) {
 961             EncodeTransportData();
 962             TransportDataHToN( &fReturnTransportData,  &fReturnTransportData);
 963             //copy to TxBuffer
 964             memcpy ( fTxData, &fReturnTransportData, sizeof ( net_transport_data_t ) );
 965         }
 966         //then others
 967         //...
 968     }
 969
 970     void JackNetSlaveInterface::DecodeSyncPacket()
 971     {
 972         //this method contains every step of sync packet informations decoding process
 973         //first : transport
 974         if (fParams.fTransportSync) {
 975             //copy received transport data to transport data structure
 976             memcpy ( &fSendTransportData, fRxData, sizeof ( net_transport_data_t ) );
 977             TransportDataNToH( &fSendTransportData,  &fSendTransportData);
 978             DecodeTransportData();
 979         }
 980         //then others
 981         //...
 982     }
 983
 984 }