00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "JackNetInterface.h"
00021 #include "JackException.h"
00022 #include "JackPlatformPlug.h"
00023 #include <assert.h>
00024
00025 using namespace std;
00026
00027
00028
00029
00030
00031
00032
00033 namespace Jack
00034 {
00035
00036
00037 JackNetInterface::JackNetInterface() : fSocket()
00038 {
00039 fTxBuffer = NULL;
00040 fRxBuffer = NULL;
00041 fNetAudioCaptureBuffer = NULL;
00042 fNetAudioPlaybackBuffer = NULL;
00043 fNetMidiCaptureBuffer = NULL;
00044 fNetMidiPlaybackBuffer = NULL;
00045 memset(&fSendTransportData, 0, sizeof(net_transport_data_t));
00046 memset(&fReturnTransportData, 0, sizeof(net_transport_data_t));
00047 }
00048
00049 JackNetInterface::JackNetInterface ( const char* multicast_ip, int port ) : fSocket ( multicast_ip, port )
00050 {
00051 strcpy(fMulticastIP, multicast_ip);
00052 fTxBuffer = NULL;
00053 fRxBuffer = NULL;
00054 fNetAudioCaptureBuffer = NULL;
00055 fNetAudioPlaybackBuffer = NULL;
00056 fNetMidiCaptureBuffer = NULL;
00057 fNetMidiPlaybackBuffer = NULL;
00058 memset(&fSendTransportData, 0, sizeof(net_transport_data_t));
00059 memset(&fReturnTransportData, 0, sizeof(net_transport_data_t));
00060 }
00061
00062 JackNetInterface::JackNetInterface ( session_params_t& params, JackNetSocket& socket, const char* multicast_ip ) : fSocket ( socket )
00063 {
00064 fParams = params;
00065 strcpy(fMulticastIP, multicast_ip);
00066 fTxBuffer = NULL;
00067 fRxBuffer = NULL;
00068 fNetAudioCaptureBuffer = NULL;
00069 fNetAudioPlaybackBuffer = NULL;
00070 fNetMidiCaptureBuffer = NULL;
00071 fNetMidiPlaybackBuffer = NULL;
00072 memset(&fSendTransportData, 0, sizeof(net_transport_data_t));
00073 memset(&fReturnTransportData, 0, sizeof(net_transport_data_t));
00074 }
00075
00076 JackNetInterface::~JackNetInterface()
00077 {
00078 jack_log ( "JackNetInterface::~JackNetInterface" );
00079
00080 fSocket.Close();
00081 delete[] fTxBuffer;
00082 delete[] fRxBuffer;
00083 delete fNetAudioCaptureBuffer;
00084 delete fNetAudioPlaybackBuffer;
00085 delete fNetMidiCaptureBuffer;
00086 delete fNetMidiPlaybackBuffer;
00087 }
00088
00089 void JackNetInterface::SetFramesPerPacket()
00090 {
00091 jack_log ( "JackNetInterface::SetFramesPerPacket" );
00092
00093 if (fParams.fSendAudioChannels == 0 && fParams.fReturnAudioChannels == 0) {
00094 fParams.fFramesPerPacket = fParams.fPeriodSize;
00095 } else {
00096 jack_nframes_t period = ( int ) powf ( 2.f, ( int ) ( log (float ( fParams.fMtu - sizeof ( packet_header_t ) )
00097 / ( max ( fParams.fReturnAudioChannels, fParams.fSendAudioChannels ) * sizeof ( sample_t ) ) ) / log ( 2. ) ) );
00098 fParams.fFramesPerPacket = ( period > fParams.fPeriodSize ) ? fParams.fPeriodSize : period;
00099 }
00100 }
00101
00102 int JackNetInterface::SetNetBufferSize()
00103 {
00104 jack_log ( "JackNetInterface::SetNetBufferSize" );
00105
00106 float audio_size, midi_size;
00107 int bufsize;
00108
00109 audio_size = fParams.fMtu * ( fParams.fPeriodSize / fParams.fFramesPerPacket );
00110
00111 midi_size = fParams.fMtu * ( max ( fParams.fSendMidiChannels, fParams.fReturnMidiChannels ) *
00112 fParams.fPeriodSize * sizeof ( sample_t ) / ( fParams.fMtu - sizeof ( packet_header_t ) ) );
00113
00114 bufsize = MAX_LATENCY * (fParams.fMtu + ( int ) audio_size + ( int ) midi_size);
00115
00116
00117 if ( fSocket.SetOption ( SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof ( bufsize ) ) == SOCKET_ERROR )
00118 return SOCKET_ERROR;
00119
00120
00121 if ( fSocket.SetOption ( SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof ( bufsize ) ) == SOCKET_ERROR )
00122 return SOCKET_ERROR;
00123
00124 return 0;
00125 }
00126
00127 int JackNetInterface::GetNMidiPckt()
00128 {
00129
00130
00131 if ( fTxHeader.fMidiDataSize <= ( fParams.fMtu - sizeof ( packet_header_t ) ) )
00132 return 1;
00133
00134 int npckt = fTxHeader.fMidiDataSize / ( fParams.fMtu - sizeof ( packet_header_t ) );
00135 if ( fTxHeader.fMidiDataSize % ( fParams.fMtu - sizeof ( packet_header_t ) ) )
00136 return ++npckt;
00137 return npckt;
00138 }
00139
00140 bool JackNetInterface::IsNextPacket()
00141 {
00142 packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );
00143
00144 if ( fRxHeader.fCycle <= 1 ) {
00145 return true;
00146 }
00147
00148 if ( ( fRxHeader.fSubCycle < ( fNSubProcess - 1 ) ) && ( rx_head->fCycle == fRxHeader.fCycle ) && ( rx_head->fSubCycle == ( fRxHeader.fSubCycle + 1 ) ) ) {
00149 return true;
00150 }
00151
00152 if ( ( rx_head->fCycle == ( fRxHeader.fCycle + 1 ) ) && ( fRxHeader.fSubCycle == ( fNSubProcess - 1 ) ) && ( rx_head->fSubCycle == 0 ) ) {
00153 return true;
00154 }
00155
00156 return false;
00157 }
00158
00159 void JackNetInterface::SetParams()
00160 {
00161
00162 fNSubProcess = fParams.fPeriodSize / fParams.fFramesPerPacket;
00163
00164
00165 fPayloadSize = fParams.fMtu - sizeof ( packet_header_t );
00166
00167
00168 strcpy ( fTxHeader.fPacketType, "header" );
00169 fTxHeader.fID = fParams.fID;
00170 fTxHeader.fCycle = 0;
00171 fTxHeader.fSubCycle = 0;
00172 fTxHeader.fMidiDataSize = 0;
00173 fTxHeader.fBitdepth = fParams.fBitdepth;
00174 fTxHeader.fIsLastPckt = 0;
00175
00176
00177 strcpy ( fRxHeader.fPacketType, "header" );
00178 fRxHeader.fID = fParams.fID;
00179 fRxHeader.fCycle = 0;
00180 fRxHeader.fSubCycle = 0;
00181 fRxHeader.fMidiDataSize = 0;
00182 fRxHeader.fBitdepth = fParams.fBitdepth;
00183 fRxHeader.fIsLastPckt = 0;
00184
00185
00186 fTxBuffer = new char[fParams.fMtu];
00187 fRxBuffer = new char[fParams.fMtu];
00188 assert ( fTxBuffer );
00189 assert ( fRxBuffer );
00190
00191
00192 fTxData = fTxBuffer + sizeof ( packet_header_t );
00193 fRxData = fRxBuffer + sizeof ( packet_header_t );
00194 }
00195
00196
00197
00198 bool JackNetMasterInterface::Init()
00199 {
00200 jack_log ( "JackNetMasterInterface::Init, ID %u.", fParams.fID );
00201
00202 session_params_t host_params;
00203 uint attempt = 0;
00204 int rx_bytes = 0;
00205
00206
00207 if ( fSocket.NewSocket() == SOCKET_ERROR )
00208 {
00209 jack_error ( "Can't create socket : %s", StrError ( NET_ERROR_CODE ) );
00210 return false;
00211 }
00212
00213
00214 if ( fSocket.SetTimeOut ( MASTER_INIT_TIMEOUT ) < 0 )
00215 jack_error ( "Can't set timeout : %s", StrError ( NET_ERROR_CODE ) );
00216
00217
00218 if ( fSocket.Connect() == SOCKET_ERROR )
00219 {
00220 jack_error ( "Can't connect : %s", StrError ( NET_ERROR_CODE ) );
00221 return false;
00222 }
00223
00224
00225 SetFramesPerPacket();
00226
00227
00228 jack_info ( "Sending parameters to %s ...", fParams.fSlaveNetName );
00229 do
00230 {
00231 session_params_t net_params;
00232 SetPacketType ( &fParams, SLAVE_SETUP );
00233 SessionParamsHToN(&fParams, &net_params);
00234
00235 if ( fSocket.Send ( &net_params, sizeof ( session_params_t ), 0 ) == SOCKET_ERROR )
00236 jack_error ( "Error in send : ", StrError ( NET_ERROR_CODE ) );
00237
00238 memset(&net_params, 0, sizeof ( session_params_t ));
00239 if ( ( ( rx_bytes = fSocket.Recv ( &net_params, sizeof ( session_params_t ), 0 ) ) == SOCKET_ERROR ) && ( fSocket.GetError() != NET_NO_DATA ) )
00240 {
00241 jack_error ( "Problem with network." );
00242 return false;
00243 }
00244
00245 SessionParamsNToH(&net_params, &host_params);
00246 }
00247 while ( ( GetPacketType ( &host_params ) != START_MASTER ) && ( ++attempt < SLAVE_SETUP_RETRY ) );
00248 if ( attempt == SLAVE_SETUP_RETRY )
00249 {
00250 jack_error ( "Slave doesn't respond, exiting." );
00251 return false;
00252 }
00253
00254
00255 if ( SetRxTimeout() == SOCKET_ERROR )
00256 {
00257 jack_error ( "Can't set rx timeout : %s", StrError ( NET_ERROR_CODE ) );
00258 return false;
00259 }
00260
00261
00262 if ( SetNetBufferSize() == SOCKET_ERROR )
00263 {
00264 jack_error ( "Can't set net buffer sizes : %s", StrError ( NET_ERROR_CODE ) );
00265 return false;
00266 }
00267
00268 return true;
00269 }
00270
00271 int JackNetMasterInterface::SetRxTimeout()
00272 {
00273 jack_log ( "JackNetMasterInterface::SetRxTimeout" );
00274
00275 float time = 0;
00276
00277 if ( ( fParams.fNetworkMode == 's' ) || ( fParams.fNetworkMode == 'n' ) )
00278 time = 2000000.f * ( static_cast<float> ( fParams.fFramesPerPacket ) / static_cast<float> ( fParams.fSampleRate ) );
00279
00280 else if ( fParams.fNetworkMode == 'f' )
00281 time = 750000.f * ( static_cast<float> ( fParams.fPeriodSize ) / static_cast<float> ( fParams.fSampleRate ) );
00282 return fSocket.SetTimeOut ( static_cast<int> ( time ) );
00283 }
00284
00285 void JackNetMasterInterface::SetParams()
00286 {
00287 jack_log ( "JackNetMasterInterface::SetParams" );
00288
00289 JackNetInterface::SetParams();
00290
00291 fTxHeader.fDataStream = 's';
00292 fRxHeader.fDataStream = 'r';
00293
00294
00295 fNetMidiCaptureBuffer = new NetMidiBuffer ( &fParams, fParams.fSendMidiChannels, fTxData );
00296 fNetMidiPlaybackBuffer = new NetMidiBuffer ( &fParams, fParams.fReturnMidiChannels, fRxData );
00297 assert ( fNetMidiCaptureBuffer );
00298 assert ( fNetMidiPlaybackBuffer );
00299
00300
00301 fNetAudioCaptureBuffer = new NetAudioBuffer ( &fParams, fParams.fSendAudioChannels, fTxData );
00302 fNetAudioPlaybackBuffer = new NetAudioBuffer ( &fParams, fParams.fReturnAudioChannels, fRxData );
00303 assert ( fNetAudioCaptureBuffer );
00304 assert ( fNetAudioPlaybackBuffer );
00305
00306
00307 fAudioTxLen = sizeof ( packet_header_t ) + fNetAudioCaptureBuffer->GetSize();
00308 fAudioRxLen = sizeof ( packet_header_t ) + fNetAudioPlaybackBuffer->GetSize();
00309 }
00310
00311 void JackNetMasterInterface::Exit()
00312 {
00313 jack_log ( "JackNetMasterInterface::Exit, ID %u", fParams.fID );
00314
00315
00316 fRunning = false;
00317
00318
00319 jack_info ( "Exiting '%s'", fParams.fName );
00320 SetPacketType ( &fParams, KILL_MASTER );
00321 JackNetSocket mcast_socket ( fMulticastIP, fSocket.GetPort() );
00322
00323 session_params_t net_params;
00324 SessionParamsHToN(&fParams, &net_params);
00325
00326 if ( mcast_socket.NewSocket() == SOCKET_ERROR )
00327 jack_error ( "Can't create socket : %s", StrError ( NET_ERROR_CODE ) );
00328 if ( mcast_socket.SendTo ( &net_params, sizeof ( session_params_t ), 0, fMulticastIP ) == SOCKET_ERROR )
00329 jack_error ( "Can't send suicide request : %s", StrError ( NET_ERROR_CODE ) );
00330
00331 mcast_socket.Close();
00332
00333
00334 ThreadExit();
00335 }
00336
00337 int JackNetMasterInterface::Recv ( size_t size, int flags )
00338 {
00339 int rx_bytes;
00340 if ( ( ( rx_bytes = fSocket.Recv ( fRxBuffer, size, flags ) ) == SOCKET_ERROR ) && fRunning )
00341 {
00342 net_error_t error = fSocket.GetError();
00343
00344 if ( error == NET_NO_DATA )
00345 return 0;
00346 else if ( error == NET_CONN_ERROR )
00347 {
00348
00349 jack_error ( "'%s' : %s, exiting.", fParams.fName, StrError ( NET_ERROR_CODE ) );
00350
00351 Exit();
00352 }
00353 else
00354 jack_error ( "Error in master receive : %s", StrError ( NET_ERROR_CODE ) );
00355 }
00356
00357 packet_header_t* header = reinterpret_cast<packet_header_t*>(fRxBuffer);
00358 PacketHeaderNToH(header, header);
00359 return rx_bytes;
00360 }
00361
00362 int JackNetMasterInterface::Send ( size_t size, int flags )
00363 {
00364 int tx_bytes;
00365 packet_header_t* header = reinterpret_cast<packet_header_t*>(fTxBuffer);
00366 PacketHeaderHToN(header, header);
00367
00368 if ( ( ( tx_bytes = fSocket.Send ( fTxBuffer, size, flags ) ) == SOCKET_ERROR ) && fRunning )
00369 {
00370 net_error_t error = fSocket.GetError();
00371 if ( error == NET_CONN_ERROR )
00372 {
00373
00374 jack_error ( "'%s' : %s, exiting.", fParams.fName, StrError ( NET_ERROR_CODE ) );
00375 Exit();
00376 }
00377 else
00378 jack_error ( "Error in master send : %s", StrError ( NET_ERROR_CODE ) );
00379 }
00380 return tx_bytes;
00381 }
00382
00383 bool JackNetMasterInterface::IsSynched()
00384 {
00385 if (fParams.fNetworkMode == 's') {
00386 return (fCycleOffset < 3);
00387 } else {
00388 return true;
00389 }
00390 }
00391
00392 int JackNetMasterInterface::SyncSend()
00393 {
00394 fTxHeader.fCycle++;
00395 fTxHeader.fSubCycle = 0;
00396 fTxHeader.fDataType = 's';
00397 fTxHeader.fIsLastPckt = ( fParams.fSendMidiChannels == 0 && fParams.fSendAudioChannels == 0) ? 1 : 0;
00398 fTxHeader.fPacketSize = fParams.fMtu;
00399 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
00400 return Send ( fTxHeader.fPacketSize, 0 );
00401 }
00402
00403 int JackNetMasterInterface::DataSend()
00404 {
00405 uint subproc;
00406
00407 if ( fParams.fSendMidiChannels > 0)
00408 {
00409
00410 fTxHeader.fDataType = 'm';
00411 fTxHeader.fMidiDataSize = fNetMidiCaptureBuffer->RenderFromJackPorts();
00412 fTxHeader.fNMidiPckt = GetNMidiPckt();
00413 for ( subproc = 0; subproc < fTxHeader.fNMidiPckt; subproc++ )
00414 {
00415 fTxHeader.fSubCycle = subproc;
00416 fTxHeader.fIsLastPckt = ( ( subproc == ( fTxHeader.fNMidiPckt - 1 ) ) && (fParams.fSendAudioChannels == 0)) ? 1 : 0;
00417 fTxHeader.fPacketSize = sizeof ( packet_header_t ) + fNetMidiCaptureBuffer->RenderToNetwork ( subproc, fTxHeader.fMidiDataSize );
00418 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
00419 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR )
00420 return SOCKET_ERROR;
00421 }
00422 }
00423
00424
00425 if ( fParams.fSendAudioChannels > 0)
00426 {
00427 fTxHeader.fDataType = 'a';
00428 fTxHeader.fMidiDataSize = 0;
00429 fTxHeader.fNMidiPckt = 0;
00430 for ( subproc = 0; subproc < fNSubProcess; subproc++ )
00431 {
00432 fTxHeader.fSubCycle = subproc;
00433 fTxHeader.fIsLastPckt = ( subproc == ( fNSubProcess - 1 ) ) ? 1 : 0;
00434 fTxHeader.fPacketSize = fAudioTxLen;
00435 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
00436 fNetAudioCaptureBuffer->RenderFromJackPorts ( subproc );
00437 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR )
00438 return SOCKET_ERROR;
00439 }
00440 }
00441
00442 return 0;
00443 }
00444
00445 int JackNetMasterInterface::SyncRecv()
00446 {
00447 packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );
00448 int rx_bytes = Recv ( fParams.fMtu, MSG_PEEK );
00449
00450 if ( ( rx_bytes == 0 ) || ( rx_bytes == SOCKET_ERROR ) )
00451 return rx_bytes;
00452
00453 fCycleOffset = fTxHeader.fCycle - rx_head->fCycle;
00454
00455 switch ( fParams.fNetworkMode )
00456 {
00457 case 's' :
00458
00459
00460
00461
00462
00463 if (fCycleOffset < 2)
00464 return 0;
00465 else
00466 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
00467
00468 if (fCycleOffset > 2) {
00469 jack_info("Warning : '%s' runs in slow network mode, but data received too late (%d cycle(s) offset)", fParams.fName, fCycleOffset);
00470 }
00471 break;
00472
00473 case 'n' :
00474
00475
00476
00477
00478 if (fCycleOffset < 1)
00479 return 0;
00480 else
00481 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
00482
00483 if (fCycleOffset != 1)
00484 jack_info("'%s' can't run in normal network mode, data received too late (%d cycle(s) offset)", fParams.fName, fCycleOffset);
00485 break;
00486
00487 case 'f' :
00488
00489
00490
00491
00492 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
00493
00494 if (fCycleOffset != 0)
00495 jack_info("'%s' can't run in fast network mode, data received too late (%d cycle(s) offset)", fParams.fName, fCycleOffset);
00496 break;
00497 }
00498
00499 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
00500 return rx_bytes;
00501 }
00502
00503 int JackNetMasterInterface::DataRecv()
00504 {
00505 int rx_bytes = 0;
00506 uint jumpcnt = 0;
00507 uint recvd_midi_pckt = 0;
00508 uint recvd_audio_pckt = 0;
00509 packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );
00510
00511 while ( !fRxHeader.fIsLastPckt )
00512 {
00513
00514 rx_bytes = Recv ( fParams.fMtu, MSG_PEEK );
00515
00516 if ( rx_bytes == SOCKET_ERROR )
00517 return rx_bytes;
00518
00519 if ( ( rx_bytes == 0 ) && ( ++jumpcnt == fNSubProcess ) )
00520 {
00521 jack_error ( "No data from %s...", fParams.fName );
00522 jumpcnt = 0;
00523 }
00524
00525 if ( rx_bytes && ( rx_head->fDataStream == 'r' ) && ( rx_head->fID == fParams.fID ) )
00526 {
00527
00528 switch ( rx_head->fDataType )
00529 {
00530 case 'm':
00531 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
00532 fRxHeader.fCycle = rx_head->fCycle;
00533 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
00534 fNetMidiPlaybackBuffer->RenderFromNetwork ( rx_head->fSubCycle, rx_bytes - sizeof ( packet_header_t ) );
00535 if ( ++recvd_midi_pckt == rx_head->fNMidiPckt )
00536 fNetMidiPlaybackBuffer->RenderToJackPorts();
00537 jumpcnt = 0;
00538 break;
00539
00540 case 'a':
00541 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
00542
00543
00544
00545 if (recvd_audio_pckt++ != rx_head->fSubCycle) {
00546 jack_error("Packet(s) missing from '%s'...", fParams.fSlaveNetName);
00547 }
00548 fRxHeader.fCycle = rx_head->fCycle;
00549 fRxHeader.fSubCycle = rx_head->fSubCycle;
00550 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
00551 fNetAudioPlaybackBuffer->RenderToJackPorts ( rx_head->fSubCycle );
00552 jumpcnt = 0;
00553 break;
00554
00555 case 's':
00556
00557
00558
00559
00560 jack_info("NetMaster : overloaded, skipping receive from '%s'", fParams.fName);
00561 return 0;
00562 }
00563 }
00564 }
00565 return rx_bytes;
00566 }
00567
00568 void JackNetMasterInterface::EncodeSyncPacket()
00569 {
00570
00571
00572 memset ( fTxData, 0, fPayloadSize );
00573
00574
00575 if (fParams.fTransportSync) {
00576 EncodeTransportData();
00577 TransportDataHToN( &fSendTransportData, &fSendTransportData);
00578
00579 memcpy ( fTxData, &fSendTransportData, sizeof ( net_transport_data_t ) );
00580 }
00581
00582
00583 }
00584
00585 void JackNetMasterInterface::DecodeSyncPacket()
00586 {
00587
00588
00589 if (fParams.fTransportSync) {
00590
00591 memcpy ( &fReturnTransportData, fRxData, sizeof ( net_transport_data_t ) );
00592 TransportDataNToH( &fReturnTransportData, &fReturnTransportData);
00593 DecodeTransportData();
00594 }
00595
00596
00597 }
00598
00599
00600
00601 uint JackNetSlaveInterface::fSlaveCounter = 0;
00602
00603 bool JackNetSlaveInterface::Init()
00604 {
00605 jack_log ( "JackNetSlaveInterface::Init()" );
00606
00607
00608 strcpy ( fParams.fPacketType, "params" );
00609 fParams.fProtocolVersion = SLAVE_PROTOCOL;
00610 SetPacketType ( &fParams, SLAVE_AVAILABLE );
00611
00612
00613 net_status_t status;
00614 do
00615 {
00616
00617 do
00618 {
00619 status = GetNetMaster();
00620 if ( status == NET_SOCKET_ERROR )
00621 return false;
00622 }
00623 while ( status != NET_CONNECTED );
00624
00625
00626 jack_info ( "Initializing connection with %s...", fParams.fMasterNetName );
00627 status = SendStartToMaster();
00628 if ( status == NET_ERROR )
00629 return false;
00630 }
00631 while ( status != NET_ROLLING );
00632
00633 return true;
00634 }
00635
00636
00637
00638 bool JackNetSlaveInterface::InitConnection()
00639 {
00640 jack_log ( "JackNetSlaveInterface::InitConnection()" );
00641
00642
00643 strcpy (fParams.fPacketType, "params");
00644 fParams.fProtocolVersion = SLAVE_PROTOCOL;
00645 SetPacketType (&fParams, SLAVE_AVAILABLE);
00646
00647 net_status_t status;
00648 do
00649 {
00650
00651 status = GetNetMaster();
00652 if (status == NET_SOCKET_ERROR)
00653 return false;
00654 }
00655 while (status != NET_CONNECTED);
00656
00657 return true;
00658 }
00659
00660 bool JackNetSlaveInterface::InitRendering()
00661 {
00662 jack_log("JackNetSlaveInterface::InitRendering()");
00663
00664 net_status_t status;
00665 do
00666 {
00667
00668 jack_info("Initializing connection with %s...", fParams.fMasterNetName);
00669 status = SendStartToMaster();
00670 if (status == NET_ERROR)
00671 return false;
00672 }
00673 while (status != NET_ROLLING);
00674
00675 return true;
00676 }
00677
00678 net_status_t JackNetSlaveInterface::GetNetMaster()
00679 {
00680 jack_log ( "JackNetSlaveInterface::GetNetMaster()" );
00681
00682 session_params_t host_params;
00683 int rx_bytes = 0;
00684
00685
00686 if ( fSocket.NewSocket() == SOCKET_ERROR )
00687 {
00688 jack_error ( "Fatal error : network unreachable - %s", StrError ( NET_ERROR_CODE ) );
00689 return NET_SOCKET_ERROR;
00690 }
00691
00692
00693 if ( fSocket.Bind() == SOCKET_ERROR )
00694 jack_error ( "Can't bind the socket : %s", StrError ( NET_ERROR_CODE ) );
00695
00696
00697 if ( fSocket.SetTimeOut ( SLAVE_INIT_TIMEOUT ) == SOCKET_ERROR )
00698 jack_error ( "Can't set timeout : %s", StrError ( NET_ERROR_CODE ) );
00699
00700
00701 if ( fSocket.SetLocalLoop() == SOCKET_ERROR )
00702 jack_error ( "Can't disable multicast loop : %s", StrError ( NET_ERROR_CODE ) );
00703
00704
00705 jack_info ( "Waiting for a master..." );
00706 do
00707 {
00708
00709 session_params_t net_params;
00710 SessionParamsHToN(&fParams, &net_params);
00711 if ( fSocket.SendTo ( &net_params, sizeof ( session_params_t ), 0, fMulticastIP ) == SOCKET_ERROR )
00712 jack_error ( "Error in data send : %s", StrError ( NET_ERROR_CODE ) );
00713
00714
00715 memset(&net_params, 0, sizeof ( session_params_t ));
00716 rx_bytes = fSocket.CatchHost ( &net_params, sizeof ( session_params_t ), 0 );
00717 SessionParamsNToH(&net_params, &host_params);
00718 if ( ( rx_bytes == SOCKET_ERROR ) && ( fSocket.GetError() != NET_NO_DATA ) )
00719 {
00720 jack_error ( "Can't receive : %s", StrError ( NET_ERROR_CODE ) );
00721 return NET_RECV_ERROR;
00722 }
00723 }
00724 while ( strcmp ( host_params.fPacketType, fParams.fPacketType ) && ( GetPacketType ( &host_params ) != SLAVE_SETUP ) );
00725
00726
00727 fParams = host_params;
00728
00729
00730 if ( SetNetBufferSize() == SOCKET_ERROR )
00731 jack_error ( "Can't set net buffer sizes : %s", StrError ( NET_ERROR_CODE ) );
00732
00733
00734 if ( fSocket.Connect() == SOCKET_ERROR )
00735 {
00736 jack_error ( "Error in connect : %s", StrError ( NET_ERROR_CODE ) );
00737 return NET_CONNECT_ERROR;
00738 }
00739
00740 return NET_CONNECTED;
00741 }
00742
00743 net_status_t JackNetSlaveInterface::SendStartToMaster()
00744 {
00745 jack_log ( "JackNetSlaveInterface::SendStartToMaster" );
00746
00747
00748 session_params_t net_params;
00749 SetPacketType ( &fParams, START_MASTER );
00750 SessionParamsHToN(&fParams, &net_params);
00751 if ( fSocket.Send ( &net_params, sizeof ( session_params_t ), 0 ) == SOCKET_ERROR )
00752 {
00753 jack_error ( "Error in send : %s", StrError ( NET_ERROR_CODE ) );
00754 return ( fSocket.GetError() == NET_CONN_ERROR ) ? NET_ERROR : NET_SEND_ERROR;
00755 }
00756 return NET_ROLLING;
00757 }
00758
00759 void JackNetSlaveInterface::SetParams()
00760 {
00761 jack_log ( "JackNetSlaveInterface::SetParams" );
00762
00763 JackNetInterface::SetParams();
00764
00765 fTxHeader.fDataStream = 'r';
00766 fRxHeader.fDataStream = 's';
00767
00768
00769 fNetMidiCaptureBuffer = new NetMidiBuffer ( &fParams, fParams.fSendMidiChannels, fRxData );
00770 fNetMidiPlaybackBuffer = new NetMidiBuffer ( &fParams, fParams.fReturnMidiChannels, fTxData );
00771
00772
00773 fNetAudioCaptureBuffer = new NetAudioBuffer ( &fParams, fParams.fSendAudioChannels, fRxData );
00774 fNetAudioPlaybackBuffer = new NetAudioBuffer ( &fParams, fParams.fReturnAudioChannels, fTxData );
00775
00776
00777 fAudioTxLen = sizeof ( packet_header_t ) + fNetAudioPlaybackBuffer->GetSize();
00778 fAudioRxLen = sizeof ( packet_header_t ) + fNetAudioCaptureBuffer->GetSize();
00779 }
00780
00781 int JackNetSlaveInterface::Recv ( size_t size, int flags )
00782 {
00783 int rx_bytes = fSocket.Recv ( fRxBuffer, size, flags );
00784
00785 if ( rx_bytes == SOCKET_ERROR )
00786 {
00787 net_error_t error = fSocket.GetError();
00788
00789 if ( error == NET_NO_DATA )
00790 jack_error ( "No data, is the master still running ?" );
00791
00792 else if ( error == NET_CONN_ERROR )
00793 {
00794 jack_error ( "Connection lost." );
00795 throw JackNetException();
00796 }
00797 else
00798 jack_error ( "Fatal error in slave receive : %s", StrError ( NET_ERROR_CODE ) );
00799 }
00800
00801 packet_header_t* header = reinterpret_cast<packet_header_t*>(fRxBuffer);
00802 PacketHeaderNToH(header, header);
00803 return rx_bytes;
00804 }
00805
00806 int JackNetSlaveInterface::Send ( size_t size, int flags )
00807 {
00808 packet_header_t* header = reinterpret_cast<packet_header_t*>(fTxBuffer);
00809 PacketHeaderHToN(header, header);
00810 int tx_bytes = fSocket.Send ( fTxBuffer, size, flags );
00811
00812
00813 if ( tx_bytes == SOCKET_ERROR )
00814 {
00815 net_error_t error = fSocket.GetError();
00816
00817 if ( error == NET_CONN_ERROR )
00818 {
00819 jack_error ( "Connection lost." );
00820 throw JackNetException();
00821 }
00822 else
00823 jack_error ( "Fatal error in slave send : %s", StrError ( NET_ERROR_CODE ) );
00824 }
00825 return tx_bytes;
00826 }
00827
00828 int JackNetSlaveInterface::SyncRecv()
00829 {
00830 int rx_bytes = 0;
00831 packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );
00832
00833 do
00834 {
00835 rx_bytes = Recv ( fParams.fMtu, 0 );
00836
00837 if ( rx_bytes == SOCKET_ERROR )
00838 return rx_bytes;
00839 }
00840 while ((strcmp(rx_head->fPacketType, "header") != 0) && (rx_head->fDataType != 's'));
00841
00842 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
00843 return rx_bytes;
00844 }
00845
00846 int JackNetSlaveInterface::DataRecv()
00847 {
00848 uint recvd_midi_pckt = 0;
00849 uint recvd_audio_pckt = 0;
00850 int rx_bytes = 0;
00851 packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );
00852
00853 while ( !fRxHeader.fIsLastPckt )
00854 {
00855 rx_bytes = Recv ( fParams.fMtu, MSG_PEEK );
00856
00857
00858 if ( rx_bytes == SOCKET_ERROR )
00859 return rx_bytes;
00860 if ( rx_bytes && ( rx_head->fDataStream == 's' ) && ( rx_head->fID == fParams.fID ) )
00861 {
00862 switch ( rx_head->fDataType )
00863 {
00864 case 'm':
00865 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
00866 fRxHeader.fCycle = rx_head->fCycle;
00867 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
00868 fNetMidiCaptureBuffer->RenderFromNetwork ( rx_head->fSubCycle, rx_bytes - sizeof ( packet_header_t ) );
00869 if ( ++recvd_midi_pckt == rx_head->fNMidiPckt )
00870 fNetMidiCaptureBuffer->RenderToJackPorts();
00871 break;
00872
00873 case 'a':
00874 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
00875
00876
00877
00878 if (recvd_audio_pckt++ != rx_head->fSubCycle) {
00879 jack_error("Packet(s) missing from '%s'...", fParams.fMasterNetName);
00880 }
00881 fRxHeader.fCycle = rx_head->fCycle;
00882 fRxHeader.fSubCycle = rx_head->fSubCycle;
00883 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
00884 fNetAudioCaptureBuffer->RenderToJackPorts ( rx_head->fSubCycle );
00885 break;
00886
00887 case 's':
00888 jack_info ( "NetSlave : overloaded, skipping receive." );
00889 return 0;
00890 }
00891 }
00892 }
00893 fRxHeader.fCycle = rx_head->fCycle;
00894 return 0;
00895 }
00896
00897 int JackNetSlaveInterface::SyncSend()
00898 {
00899
00900 if ( fParams.fSlaveSyncMode )
00901 fTxHeader.fCycle = fRxHeader.fCycle;
00902 else
00903 fTxHeader.fCycle++;
00904 fTxHeader.fSubCycle = 0;
00905 fTxHeader.fDataType = 's';
00906 fTxHeader.fIsLastPckt = ( fParams.fReturnMidiChannels == 0 && fParams.fReturnAudioChannels == 0) ? 1 : 0;
00907 fTxHeader.fPacketSize = fParams.fMtu;
00908 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
00909 return Send ( fTxHeader.fPacketSize, 0 );
00910 }
00911
00912 int JackNetSlaveInterface::DataSend()
00913 {
00914 uint subproc;
00915
00916
00917 if ( fParams.fReturnMidiChannels > 0)
00918 {
00919 fTxHeader.fDataType = 'm';
00920 fTxHeader.fMidiDataSize = fNetMidiPlaybackBuffer->RenderFromJackPorts();
00921 fTxHeader.fNMidiPckt = GetNMidiPckt();
00922 for ( subproc = 0; subproc < fTxHeader.fNMidiPckt; subproc++ )
00923 {
00924 fTxHeader.fSubCycle = subproc;
00925 fTxHeader.fIsLastPckt = ( ( subproc == ( fTxHeader.fNMidiPckt - 1 ) ) && !fParams.fReturnAudioChannels ) ? 1 : 0;
00926 fTxHeader.fPacketSize = sizeof ( packet_header_t ) + fNetMidiPlaybackBuffer->RenderToNetwork ( subproc, fTxHeader.fMidiDataSize );
00927 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
00928 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR )
00929 return SOCKET_ERROR;
00930 }
00931 }
00932
00933
00934 if ( fParams.fReturnAudioChannels > 0)
00935 {
00936 fTxHeader.fDataType = 'a';
00937 fTxHeader.fMidiDataSize = 0;
00938 fTxHeader.fNMidiPckt = 0;
00939 for ( subproc = 0; subproc < fNSubProcess; subproc++ )
00940 {
00941 fTxHeader.fSubCycle = subproc;
00942 fTxHeader.fIsLastPckt = ( subproc == ( fNSubProcess - 1 ) ) ? 1 : 0;
00943 fTxHeader.fPacketSize = fAudioTxLen;
00944 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
00945 fNetAudioPlaybackBuffer->RenderFromJackPorts ( subproc );
00946 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR )
00947 return SOCKET_ERROR;
00948 }
00949 }
00950 return 0;
00951 }
00952
00953
00954 void JackNetSlaveInterface::EncodeSyncPacket()
00955 {
00956
00957
00958 memset ( fTxData, 0, fPayloadSize );
00959
00960 if (fParams.fTransportSync) {
00961 EncodeTransportData();
00962 TransportDataHToN( &fReturnTransportData, &fReturnTransportData);
00963
00964 memcpy ( fTxData, &fReturnTransportData, sizeof ( net_transport_data_t ) );
00965 }
00966
00967
00968 }
00969
00970 void JackNetSlaveInterface::DecodeSyncPacket()
00971 {
00972
00973
00974 if (fParams.fTransportSync) {
00975
00976 memcpy ( &fSendTransportData, fRxData, sizeof ( net_transport_data_t ) );
00977 TransportDataNToH( &fSendTransportData, &fSendTransportData);
00978 DecodeTransportData();
00979 }
00980
00981
00982 }
00983
00984 }