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