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