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 jack_error ( "Can't create socket : %s", StrError ( NET_ERROR_CODE ) );
00209 return false;
00210 }
00211
00212
00213 if ( fSocket.SetTimeOut ( MASTER_INIT_TIMEOUT ) < 0 )
00214 jack_error ( "Can't set timeout : %s", StrError ( NET_ERROR_CODE ) );
00215
00216
00217 if ( fSocket.Connect() == SOCKET_ERROR ) {
00218 jack_error ( "Can't connect : %s", StrError ( NET_ERROR_CODE ) );
00219 return false;
00220 }
00221
00222
00223 SetFramesPerPacket();
00224
00225
00226 jack_info ( "Sending parameters to %s ...", fParams.fSlaveNetName );
00227 do
00228 {
00229 session_params_t net_params;
00230 SetPacketType ( &fParams, SLAVE_SETUP );
00231 SessionParamsHToN(&fParams, &net_params);
00232
00233 if ( fSocket.Send ( &net_params, sizeof ( session_params_t ), 0 ) == SOCKET_ERROR )
00234 jack_error ( "Error in send : ", StrError ( NET_ERROR_CODE ) );
00235
00236 memset(&net_params, 0, sizeof ( session_params_t ));
00237 if ( ( ( rx_bytes = fSocket.Recv ( &net_params, sizeof ( session_params_t ), 0 ) ) == SOCKET_ERROR ) && ( fSocket.GetError() != NET_NO_DATA ) )
00238 {
00239 jack_error ( "Problem with network." );
00240 return false;
00241 }
00242
00243 SessionParamsNToH(&net_params, &host_params);
00244 }
00245 while ( ( GetPacketType ( &host_params ) != START_MASTER ) && ( ++attempt < SLAVE_SETUP_RETRY ) );
00246 if ( attempt == SLAVE_SETUP_RETRY ) {
00247 jack_error ( "Slave doesn't respond, exiting." );
00248 return false;
00249 }
00250
00251
00252 if ( SetRxTimeout() == SOCKET_ERROR ) {
00253 jack_error ( "Can't set rx timeout : %s", StrError ( NET_ERROR_CODE ) );
00254 return false;
00255 }
00256
00257
00258 if ( SetNetBufferSize() == SOCKET_ERROR ) {
00259 jack_error ( "Can't set net buffer sizes : %s", StrError ( NET_ERROR_CODE ) );
00260 return false;
00261 }
00262
00263 return true;
00264 }
00265
00266 int JackNetMasterInterface::SetRxTimeout()
00267 {
00268 jack_log ( "JackNetMasterInterface::SetRxTimeout" );
00269
00270 float time = 0;
00271
00272 if ( ( fParams.fNetworkMode == 's' ) || ( fParams.fNetworkMode == 'n' ) )
00273 time = 2000000.f * ( static_cast<float> ( fParams.fFramesPerPacket ) / static_cast<float> ( fParams.fSampleRate ) );
00274
00275 else if ( fParams.fNetworkMode == 'f' )
00276 time = 750000.f * ( static_cast<float> ( fParams.fPeriodSize ) / static_cast<float> ( fParams.fSampleRate ) );
00277 return fSocket.SetTimeOut ( static_cast<int> ( time ) );
00278 }
00279
00280 void JackNetMasterInterface::SetParams()
00281 {
00282 jack_log ( "JackNetMasterInterface::SetParams" );
00283
00284 JackNetInterface::SetParams();
00285
00286 fTxHeader.fDataStream = 's';
00287 fRxHeader.fDataStream = 'r';
00288
00289
00290 fNetMidiCaptureBuffer = new NetMidiBuffer ( &fParams, fParams.fSendMidiChannels, fTxData );
00291 fNetMidiPlaybackBuffer = new NetMidiBuffer ( &fParams, fParams.fReturnMidiChannels, fRxData );
00292 assert ( fNetMidiCaptureBuffer );
00293 assert ( fNetMidiPlaybackBuffer );
00294
00295
00296 fNetAudioCaptureBuffer = new NetAudioBuffer ( &fParams, fParams.fSendAudioChannels, fTxData );
00297 fNetAudioPlaybackBuffer = new NetAudioBuffer ( &fParams, fParams.fReturnAudioChannels, fRxData );
00298 assert ( fNetAudioCaptureBuffer );
00299 assert ( fNetAudioPlaybackBuffer );
00300
00301
00302 fAudioTxLen = sizeof ( packet_header_t ) + fNetAudioCaptureBuffer->GetSize();
00303 fAudioRxLen = sizeof ( packet_header_t ) + fNetAudioPlaybackBuffer->GetSize();
00304 }
00305
00306 void JackNetMasterInterface::Exit()
00307 {
00308 jack_log ( "JackNetMasterInterface::Exit, ID %u", fParams.fID );
00309
00310
00311 fRunning = false;
00312
00313
00314 jack_info ( "Exiting '%s'", fParams.fName );
00315 SetPacketType ( &fParams, KILL_MASTER );
00316 JackNetSocket mcast_socket ( fMulticastIP, fSocket.GetPort() );
00317
00318 session_params_t net_params;
00319 SessionParamsHToN(&fParams, &net_params);
00320
00321 if ( mcast_socket.NewSocket() == SOCKET_ERROR )
00322 jack_error ( "Can't create socket : %s", StrError ( NET_ERROR_CODE ) );
00323 if ( mcast_socket.SendTo ( &net_params, sizeof ( session_params_t ), 0, fMulticastIP ) == SOCKET_ERROR )
00324 jack_error ( "Can't send suicide request : %s", StrError ( NET_ERROR_CODE ) );
00325
00326 mcast_socket.Close();
00327 }
00328
00329 int JackNetMasterInterface::Recv ( size_t size, int flags )
00330 {
00331 int rx_bytes;
00332 if ( ( ( rx_bytes = fSocket.Recv ( fRxBuffer, size, flags ) ) == SOCKET_ERROR ) && fRunning )
00333 {
00334 net_error_t error = fSocket.GetError();
00335
00336 if ( error == NET_NO_DATA )
00337 return 0;
00338 else if ( error == NET_CONN_ERROR )
00339 {
00340
00341 jack_error ( "'%s' : %s, exiting.", fParams.fName, StrError ( NET_ERROR_CODE ) );
00342
00343 Exit();
00344
00345
00346 ThreadExit();
00347 }
00348 else
00349 jack_error ( "Error in master receive : %s", StrError ( NET_ERROR_CODE ) );
00350 }
00351
00352 packet_header_t* header = reinterpret_cast<packet_header_t*>(fRxBuffer);
00353 PacketHeaderNToH(header, header);
00354 return rx_bytes;
00355 }
00356
00357 int JackNetMasterInterface::Send ( size_t size, int flags )
00358 {
00359 int tx_bytes;
00360 packet_header_t* header = reinterpret_cast<packet_header_t*>(fTxBuffer);
00361 PacketHeaderHToN(header, header);
00362
00363 if ( ( ( tx_bytes = fSocket.Send ( fTxBuffer, size, flags ) ) == SOCKET_ERROR ) && fRunning )
00364 {
00365 net_error_t error = fSocket.GetError();
00366 if ( error == NET_CONN_ERROR )
00367 {
00368
00369 jack_error ( "'%s' : %s, exiting.", fParams.fName, StrError ( NET_ERROR_CODE ) );
00370 Exit();
00371
00372
00373 ThreadExit();
00374 }
00375 else
00376 jack_error ( "Error in master send : %s", StrError ( NET_ERROR_CODE ) );
00377 }
00378 return tx_bytes;
00379 }
00380
00381 bool JackNetMasterInterface::IsSynched()
00382 {
00383 if (fParams.fNetworkMode == 's') {
00384 return (fCycleOffset < 3);
00385 } else {
00386 return true;
00387 }
00388 }
00389
00390 int JackNetMasterInterface::SyncSend()
00391 {
00392 fTxHeader.fCycle++;
00393 fTxHeader.fSubCycle = 0;
00394 fTxHeader.fDataType = 's';
00395 fTxHeader.fIsLastPckt = ( fParams.fSendMidiChannels == 0 && fParams.fSendAudioChannels == 0) ? 1 : 0;
00396 fTxHeader.fPacketSize = fParams.fMtu;
00397 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
00398 return Send ( fTxHeader.fPacketSize, 0 );
00399 }
00400
00401 int JackNetMasterInterface::DataSend()
00402 {
00403 uint subproc;
00404
00405 if ( fParams.fSendMidiChannels > 0)
00406 {
00407
00408 fTxHeader.fDataType = 'm';
00409 fTxHeader.fMidiDataSize = fNetMidiCaptureBuffer->RenderFromJackPorts();
00410 fTxHeader.fNMidiPckt = GetNMidiPckt();
00411 for ( subproc = 0; subproc < fTxHeader.fNMidiPckt; subproc++ )
00412 {
00413 fTxHeader.fSubCycle = subproc;
00414 fTxHeader.fIsLastPckt = ( ( subproc == ( fTxHeader.fNMidiPckt - 1 ) ) && (fParams.fSendAudioChannels == 0)) ? 1 : 0;
00415 fTxHeader.fPacketSize = sizeof ( packet_header_t ) + fNetMidiCaptureBuffer->RenderToNetwork ( subproc, fTxHeader.fMidiDataSize );
00416 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
00417 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR )
00418 return SOCKET_ERROR;
00419 }
00420 }
00421
00422
00423 if ( fParams.fSendAudioChannels > 0)
00424 {
00425 fTxHeader.fDataType = 'a';
00426 fTxHeader.fMidiDataSize = 0;
00427 fTxHeader.fNMidiPckt = 0;
00428 for ( subproc = 0; subproc < fNSubProcess; subproc++ )
00429 {
00430 fTxHeader.fSubCycle = subproc;
00431 fTxHeader.fIsLastPckt = ( subproc == ( fNSubProcess - 1 ) ) ? 1 : 0;
00432 fTxHeader.fPacketSize = fAudioTxLen;
00433 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );
00434 fNetAudioCaptureBuffer->RenderFromJackPorts ( subproc );
00435 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR )
00436 return SOCKET_ERROR;
00437 }
00438 }
00439
00440 return 0;
00441 }
00442
00443 int JackNetMasterInterface::SyncRecv()
00444 {
00445 packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );
00446 int rx_bytes = Recv ( fParams.fMtu, MSG_PEEK );
00447
00448 if ( ( rx_bytes == 0 ) || ( rx_bytes == SOCKET_ERROR ) )
00449 return rx_bytes;
00450
00451 fCycleOffset = fTxHeader.fCycle - rx_head->fCycle;
00452
00453 switch ( fParams.fNetworkMode )
00454 {
00455 case 's' :
00456
00457
00458
00459
00460
00461 if (fCycleOffset < 2)
00462 return 0;
00463 else
00464 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
00465
00466 if (fCycleOffset > 2) {
00467 jack_info("Warning : '%s' runs in slow network mode, but data received too late (%d cycle(s) offset)", fParams.fName, fCycleOffset);
00468 }
00469 break;
00470
00471 case 'n' :
00472
00473
00474
00475
00476 if (fCycleOffset < 1)
00477 return 0;
00478 else
00479 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
00480
00481 if (fCycleOffset != 1)
00482 jack_info("'%s' can't run in normal network mode, data received too late (%d cycle(s) offset)", fParams.fName, fCycleOffset);
00483 break;
00484
00485 case 'f' :
00486
00487
00488
00489
00490 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
00491
00492 if (fCycleOffset != 0)
00493 jack_info("'%s' can't run in fast network mode, data received too late (%d cycle(s) offset)", fParams.fName, fCycleOffset);
00494 break;
00495 }
00496
00497 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
00498 return rx_bytes;
00499 }
00500
00501 int JackNetMasterInterface::DataRecv()
00502 {
00503 int rx_bytes = 0;
00504 uint jumpcnt = 0;
00505 uint recvd_midi_pckt = 0;
00506 uint recvd_audio_pckt = 0;
00507 packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );
00508
00509 while ( !fRxHeader.fIsLastPckt )
00510 {
00511
00512 rx_bytes = Recv ( fParams.fMtu, MSG_PEEK );
00513
00514 if ( rx_bytes == SOCKET_ERROR )
00515 return rx_bytes;
00516
00517 if ( ( rx_bytes == 0 ) && ( ++jumpcnt == fNSubProcess ) )
00518 {
00519 jack_error ( "No data from %s...", fParams.fName );
00520 jumpcnt = 0;
00521 }
00522
00523 if ( rx_bytes && ( rx_head->fDataStream == 'r' ) && ( rx_head->fID == fParams.fID ) )
00524 {
00525
00526 switch ( rx_head->fDataType )
00527 {
00528 case 'm':
00529 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
00530 fRxHeader.fCycle = rx_head->fCycle;
00531 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
00532 fNetMidiPlaybackBuffer->RenderFromNetwork ( rx_head->fSubCycle, rx_bytes - sizeof ( packet_header_t ) );
00533 if ( ++recvd_midi_pckt == rx_head->fNMidiPckt )
00534 fNetMidiPlaybackBuffer->RenderToJackPorts();
00535 jumpcnt = 0;
00536 break;
00537
00538 case 'a':
00539 rx_bytes = Recv ( rx_head->fPacketSize, 0 );
00540
00541
00542
00543 if (recvd_audio_pckt++ != rx_head->fSubCycle) {
00544 jack_error("Packet(s) missing from '%s'...", fParams.fSlaveNetName);
00545 }
00546 fRxHeader.fCycle = rx_head->fCycle;
00547 fRxHeader.fSubCycle = rx_head->fSubCycle;
00548 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
00549 fNetAudioPlaybackBuffer->RenderToJackPorts ( rx_head->fSubCycle );
00550 jumpcnt = 0;
00551 break;
00552
00553 case 's':
00554
00555
00556
00557
00558 jack_info("NetMaster : overloaded, skipping receive from '%s'", fParams.fName);
00559 return 0;
00560 }
00561 }
00562 }
00563 return rx_bytes;
00564 }
00565
00566 void JackNetMasterInterface::EncodeSyncPacket()
00567 {
00568
00569
00570 memset ( fTxData, 0, fPayloadSize );
00571
00572
00573 if (fParams.fTransportSync) {
00574 EncodeTransportData();
00575 TransportDataHToN( &fSendTransportData, &fSendTransportData);
00576
00577 memcpy ( fTxData, &fSendTransportData, sizeof ( net_transport_data_t ) );
00578 }
00579
00580
00581 }
00582
00583 void JackNetMasterInterface::DecodeSyncPacket()
00584 {
00585
00586
00587 if (fParams.fTransportSync) {
00588
00589 memcpy ( &fReturnTransportData, fRxData, sizeof ( net_transport_data_t ) );
00590 TransportDataNToH( &fReturnTransportData, &fReturnTransportData);
00591 DecodeTransportData();
00592 }
00593
00594
00595 }
00596
00597
00598
00599 uint JackNetSlaveInterface::fSlaveCounter = 0;
00600
00601 bool JackNetSlaveInterface::Init()
00602 {
00603 jack_log ( "JackNetSlaveInterface::Init()" );
00604
00605
00606 strcpy ( fParams.fPacketType, "params" );
00607 fParams.fProtocolVersion = SLAVE_PROTOCOL;
00608 SetPacketType ( &fParams, SLAVE_AVAILABLE );
00609
00610
00611 net_status_t status;
00612 do
00613 {
00614
00615 do
00616 {
00617 status = SendAvailableToMaster();
00618 if ( status == NET_SOCKET_ERROR )
00619 return false;
00620 }
00621 while ( status != NET_CONNECTED );
00622
00623
00624 jack_info ( "Initializing connection with %s...", fParams.fMasterNetName );
00625 status = SendStartToMaster();
00626 if ( status == NET_ERROR )
00627 return false;
00628 }
00629 while ( status != NET_ROLLING );
00630
00631 return true;
00632 }
00633
00634
00635
00636 bool JackNetSlaveInterface::InitConnection()
00637 {
00638 jack_log ( "JackNetSlaveInterface::InitConnection()" );
00639
00640
00641 strcpy (fParams.fPacketType, "params");
00642 fParams.fProtocolVersion = SLAVE_PROTOCOL;
00643 SetPacketType (&fParams, SLAVE_AVAILABLE);
00644
00645 net_status_t status;
00646 do
00647 {
00648
00649 status = SendAvailableToMaster();
00650 if (status == NET_SOCKET_ERROR)
00651 return false;
00652 }
00653 while (status != NET_CONNECTED);
00654
00655 return true;
00656 }
00657
00658 bool JackNetSlaveInterface::InitRendering()
00659 {
00660 jack_log("JackNetSlaveInterface::InitRendering()");
00661
00662 net_status_t status;
00663 do
00664 {
00665
00666 jack_info("Initializing connection with %s...", fParams.fMasterNetName);
00667 status = SendStartToMaster();
00668 if (status == NET_ERROR)
00669 return false;
00670 }
00671 while (status != NET_ROLLING);
00672
00673 return true;
00674 }
00675
00676 net_status_t JackNetSlaveInterface::SendAvailableToMaster()
00677 {
00678 jack_log ( "JackNetSlaveInterface::SendAvailableToMaster()" );
00679
00680 session_params_t host_params;
00681 int rx_bytes = 0;
00682
00683
00684 if ( fSocket.NewSocket() == SOCKET_ERROR ) {
00685 jack_error ( "Fatal error : network unreachable - %s", StrError ( NET_ERROR_CODE ) );
00686 return NET_SOCKET_ERROR;
00687 }
00688
00689
00690 if ( fSocket.Bind() == SOCKET_ERROR ) {
00691 jack_error ( "Can't bind the socket : %s", StrError ( NET_ERROR_CODE ) );
00692 return NET_SOCKET_ERROR;
00693 }
00694
00695
00696 if ( fSocket.SetTimeOut ( SLAVE_INIT_TIMEOUT ) == SOCKET_ERROR )
00697 jack_error ( "Can't set timeout : %s", StrError ( NET_ERROR_CODE ) );
00698
00699
00700 if ( fSocket.SetLocalLoop() == SOCKET_ERROR )
00701 jack_error ( "Can't disable multicast loop : %s", StrError ( NET_ERROR_CODE ) );
00702
00703
00704 jack_info ( "Waiting for a master..." );
00705 do
00706 {
00707
00708 session_params_t net_params;
00709 SessionParamsHToN(&fParams, &net_params);
00710 if ( fSocket.SendTo ( &net_params, sizeof ( session_params_t ), 0, fMulticastIP ) == SOCKET_ERROR )
00711 jack_error ( "Error in data send : %s", StrError ( NET_ERROR_CODE ) );
00712
00713
00714 memset(&net_params, 0, sizeof ( session_params_t ));
00715 rx_bytes = fSocket.CatchHost ( &net_params, sizeof ( session_params_t ), 0 );
00716 SessionParamsNToH(&net_params, &host_params);
00717 if ( ( rx_bytes == SOCKET_ERROR ) && ( fSocket.GetError() != NET_NO_DATA ) )
00718 {
00719 jack_error ( "Can't receive : %s", StrError ( NET_ERROR_CODE ) );
00720 return NET_RECV_ERROR;
00721 }
00722 }
00723 while ( strcmp ( host_params.fPacketType, fParams.fPacketType ) && ( GetPacketType ( &host_params ) != SLAVE_SETUP ) );
00724
00725
00726 fParams = host_params;
00727
00728
00729 if ( SetNetBufferSize() == SOCKET_ERROR ) {
00730 jack_error ( "Can't set net buffer sizes : %s", StrError ( NET_ERROR_CODE ) );
00731 return NET_SOCKET_ERROR;
00732 }
00733
00734
00735 if ( fSocket.Connect() == SOCKET_ERROR ) {
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 }