00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "JackNetDriver.h"
00021 #include "JackEngineControl.h"
00022 #include "JackGraphManager.h"
00023 #include "JackWaitThreadedDriver.h"
00024
00025
00026 using namespace std;
00027
00028 namespace Jack
00029 {
00030 JackNetDriver::JackNetDriver ( const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table,
00031 const char* ip, int port, int mtu, int midi_input_ports, int midi_output_ports,
00032 char* net_name, uint transport_sync, char network_mode )
00033 : JackAudioDriver ( name, alias, engine, table ), JackNetSlaveInterface ( ip, port )
00034 {
00035 jack_log ( "JackNetDriver::JackNetDriver ip %s, port %d", ip, port );
00036
00037
00038 if ( strcmp ( net_name, "" ) == 0 )
00039 GetHostName ( net_name, JACK_CLIENT_NAME_SIZE );
00040
00041 fParams.fMtu = mtu;
00042 fParams.fSendMidiChannels = midi_input_ports;
00043 fParams.fReturnMidiChannels = midi_output_ports;
00044 strcpy ( fParams.fName, net_name );
00045 fSocket.GetName ( fParams.fSlaveNetName );
00046 fParams.fTransportSync = transport_sync;
00047 fParams.fNetworkMode = network_mode;
00048 fLastTimebaseMaster = -1;
00049 fMidiCapturePortList = NULL;
00050 fMidiPlaybackPortList = NULL;
00051 #ifdef JACK_MONITOR
00052 fNetTimeMon = NULL;
00053 #endif
00054 }
00055
00056 JackNetDriver::~JackNetDriver()
00057 {
00058 delete[] fMidiCapturePortList;
00059 delete[] fMidiPlaybackPortList;
00060 #ifdef JACK_MONITOR
00061 delete fNetTimeMon;
00062 #endif
00063 }
00064
00065
00066 int JackNetDriver::Open ( jack_nframes_t buffer_size, jack_nframes_t samplerate, bool capturing, bool playing,
00067 int inchannels, int outchannels, bool monitor,
00068 const char* capture_driver_name, const char* playback_driver_name,
00069 jack_nframes_t capture_latency, jack_nframes_t playback_latency )
00070 {
00071 if ( JackAudioDriver::Open ( buffer_size,
00072 samplerate,
00073 capturing,
00074 playing,
00075 inchannels,
00076 outchannels,
00077 monitor,
00078 capture_driver_name,
00079 playback_driver_name,
00080 capture_latency,
00081 playback_latency ) == 0 )
00082 {
00083 fEngineControl->fPeriod = 0;
00084 fEngineControl->fComputation = 500 * 1000;
00085 fEngineControl->fConstraint = 500 * 1000;
00086 return 0;
00087 }
00088 else
00089 {
00090 return -1;
00091 }
00092 }
00093
00094 #ifdef JACK_MONITOR
00095 int JackNetDriver::Close()
00096 {
00097 if ( fNetTimeMon )
00098 fNetTimeMon->Save();
00099 return JackDriver::Close();
00100 }
00101 #endif
00102
00103 int JackNetDriver::Attach()
00104 {
00105 return 0;
00106 }
00107
00108 int JackNetDriver::Detach()
00109 {
00110 return 0;
00111 }
00112
00113
00114 bool JackNetDriver::Init()
00115 {
00116 jack_log ( "JackNetDriver::Init()" );
00117
00118
00119 if ( fSocket.IsSocket() )
00120 Restart();
00121
00122
00123 fParams.fSendAudioChannels = fCaptureChannels;
00124 fParams.fReturnAudioChannels = fPlaybackChannels;
00125 fParams.fSlaveSyncMode = fEngineControl->fSyncMode;
00126
00127
00128 jack_info ( "Net driver started in %s mode %s Master's transport sync.",
00129 ( fParams.fSlaveSyncMode ) ? "sync" : "async", ( fParams.fTransportSync ) ? "with" : "without" );
00130
00131
00132 if ( !JackNetSlaveInterface::Init() )
00133 return false;
00134
00135
00136 SetParams();
00137
00138
00139 fMidiCapturePortList = new jack_port_id_t [fParams.fSendMidiChannels];
00140 fMidiPlaybackPortList = new jack_port_id_t [fParams.fReturnMidiChannels];
00141 assert ( fMidiCapturePortList );
00142 assert ( fMidiPlaybackPortList );
00143
00144
00145 if ( AllocPorts() != 0 )
00146 {
00147 jack_error ( "Can't allocate ports." );
00148 return false;
00149 }
00150
00151
00152 SessionParamsDisplay ( &fParams );
00153
00154
00155 #ifdef JACK_MONITOR
00156 string plot_name;
00157
00158 plot_name = string ( fParams.fName );
00159 plot_name += string ( "_slave" );
00160 plot_name += ( fEngineControl->fSyncMode ) ? string ( "_sync" ) : string ( "_async" );
00161 switch ( fParams.fNetworkMode )
00162 {
00163 case 's' :
00164 plot_name += string ( "_slow" );
00165 break;
00166
00167 case 'n' :
00168 plot_name += string ( "_normal" );
00169 break;
00170
00171 case 'f' :
00172 plot_name += string ( "_fast" );
00173 break;
00174 }
00175 fNetTimeMon = new JackGnuPlotMonitor<float> ( 128, 5, plot_name );
00176 string net_time_mon_fields[] =
00177 {
00178 string ( "sync decoded" ),
00179 string ( "end of read" ),
00180 string ( "start of write" ),
00181 string ( "sync send" ),
00182 string ( "end of write" )
00183 };
00184 string net_time_mon_options[] =
00185 {
00186 string ( "set xlabel \"audio cycles\"" ),
00187 string ( "set ylabel \"% of audio cycle\"" )
00188 };
00189 fNetTimeMon->SetPlotFile ( net_time_mon_options, 2, net_time_mon_fields, 5 );
00190 #endif
00191
00192 JackAudioDriver::SetBufferSize ( fParams.fPeriodSize );
00193 JackAudioDriver::SetSampleRate ( fParams.fSampleRate );
00194
00195 JackDriver::NotifyBufferSize ( fParams.fPeriodSize );
00196 JackDriver::NotifySampleRate ( fParams.fSampleRate );
00197
00198
00199 fEngineControl->fTransport.SetNetworkSync ( true );
00200 return true;
00201 }
00202
00203 void JackNetDriver::Restart()
00204 {
00205 jack_log ( "JackNetDriver::Restart" );
00206
00207 jack_info ( "Restarting driver..." );
00208 delete[] fTxBuffer;
00209 fTxBuffer = NULL;
00210 delete[] fRxBuffer;
00211 fRxBuffer = NULL;
00212 delete fNetAudioCaptureBuffer;
00213 fNetAudioCaptureBuffer = NULL;
00214 delete fNetAudioPlaybackBuffer;
00215 fNetAudioPlaybackBuffer = NULL;
00216 delete fNetMidiCaptureBuffer;
00217 fNetMidiCaptureBuffer = NULL;
00218 delete fNetMidiPlaybackBuffer;
00219 fNetMidiPlaybackBuffer = NULL;
00220 FreePorts();
00221 delete[] fMidiCapturePortList;
00222 fMidiCapturePortList = NULL;
00223 delete[] fMidiPlaybackPortList;
00224 fMidiPlaybackPortList = NULL;
00225 #ifdef JACK_MONITOR
00226 delete fNetTimeMon;
00227 fNetTimeMon = NULL;
00228 #endif
00229 }
00230
00231
00232 int JackNetDriver::AllocPorts()
00233 {
00234 jack_log ( "JackNetDriver::AllocPorts fBufferSize = %ld fSampleRate = %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate );
00235
00236 JackPort* port;
00237 jack_port_id_t port_id;
00238 char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];
00239 char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];
00240 unsigned long port_flags;
00241 int audio_port_index;
00242 uint midi_port_index;
00243
00244
00245 port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;
00246 for ( audio_port_index = 0; audio_port_index < fCaptureChannels; audio_port_index++ )
00247 {
00248 snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:out%d", fAliasName, fCaptureDriverName, audio_port_index + 1 );
00249 snprintf ( name, sizeof ( name ) - 1, "%s:capture_%d", fClientControl.fName, audio_port_index + 1 );
00250 if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE,
00251 static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )
00252 {
00253 jack_error ( "driver: cannot register port for %s", name );
00254 return -1;
00255 }
00256 port = fGraphManager->GetPort ( port_id );
00257 port->SetAlias ( alias );
00258
00259 port->SetLatency ( fEngineControl->fBufferSize );
00260 fCapturePortList[audio_port_index] = port_id;
00261 jack_log ( "JackNetDriver::AllocPorts() fCapturePortList[%d] audio_port_index = %ld fPortLatency = %ld", audio_port_index, port_id, port->GetLatency() );
00262 }
00263 port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;
00264 for ( audio_port_index = 0; audio_port_index < fPlaybackChannels; audio_port_index++ )
00265 {
00266 snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:in%d", fAliasName, fPlaybackDriverName, audio_port_index + 1 );
00267 snprintf ( name, sizeof ( name ) - 1, "%s:playback_%d",fClientControl.fName, audio_port_index + 1 );
00268 if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE,
00269 static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )
00270 {
00271 jack_error ( "driver: cannot register port for %s", name );
00272 return -1;
00273 }
00274 port = fGraphManager->GetPort ( port_id );
00275 port->SetAlias ( alias );
00276
00277 switch ( fParams.fNetworkMode )
00278 {
00279 case 'f' :
00280 port->SetLatency ( ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize );
00281 break;
00282 case 'n' :
00283 port->SetLatency ( fEngineControl->fBufferSize + ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize );
00284 break;
00285 case 's' :
00286 port->SetLatency ( 2 * fEngineControl->fBufferSize + ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize );
00287 break;
00288 }
00289 fPlaybackPortList[audio_port_index] = port_id;
00290 jack_log ( "JackNetDriver::AllocPorts() fPlaybackPortList[%d] audio_port_index = %ld fPortLatency = %ld", audio_port_index, port_id, port->GetLatency() );
00291 }
00292
00293 port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;
00294 for ( midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++ )
00295 {
00296 snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:out%d", fAliasName, fCaptureDriverName, midi_port_index + 1 );
00297 snprintf ( name, sizeof ( name ) - 1, "%s:midi_capture_%d", fClientControl.fName, midi_port_index + 1 );
00298 if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_MIDI_TYPE,
00299 static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )
00300 {
00301 jack_error ( "driver: cannot register port for %s", name );
00302 return -1;
00303 }
00304 port = fGraphManager->GetPort ( port_id );
00305
00306 port->SetLatency ( fEngineControl->fBufferSize );
00307 fMidiCapturePortList[midi_port_index] = port_id;
00308 jack_log ( "JackNetDriver::AllocPorts() fMidiCapturePortList[%d] midi_port_index = %ld fPortLatency = %ld", midi_port_index, port_id, port->GetLatency() );
00309 }
00310
00311 port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;
00312 for ( midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++ )
00313 {
00314 snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:in%d", fAliasName, fPlaybackDriverName, midi_port_index + 1 );
00315 snprintf ( name, sizeof ( name ) - 1, "%s:midi_playback_%d", fClientControl.fName, midi_port_index + 1 );
00316 if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_MIDI_TYPE,
00317 static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )
00318 {
00319 jack_error ( "driver: cannot register port for %s", name );
00320 return -1;
00321 }
00322 port = fGraphManager->GetPort ( port_id );
00323
00324 switch ( fParams.fNetworkMode )
00325 {
00326 case 'f' :
00327 port->SetLatency ( ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize );
00328 break;
00329 case 'n' :
00330 port->SetLatency ( fEngineControl->fBufferSize + ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize ) ;
00331 break;
00332 case 's' :
00333 port->SetLatency ( 2 * fEngineControl->fBufferSize + ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize );
00334 break;
00335 }
00336 fMidiPlaybackPortList[midi_port_index] = port_id;
00337 jack_log ( "JackNetDriver::AllocPorts() fMidiPlaybackPortList[%d] midi_port_index = %ld fPortLatency = %ld", midi_port_index, port_id, port->GetLatency() );
00338 }
00339
00340 return 0;
00341 }
00342
00343 int JackNetDriver::FreePorts()
00344 {
00345 jack_log ( "JackNetDriver::FreePorts" );
00346
00347 int audio_port_index;
00348 uint midi_port_index;
00349 for ( audio_port_index = 0; audio_port_index < fCaptureChannels; audio_port_index++ )
00350 fGraphManager->ReleasePort ( fClientControl.fRefNum, fCapturePortList[audio_port_index] );
00351 for ( audio_port_index = 0; audio_port_index < fPlaybackChannels; audio_port_index++ )
00352 fGraphManager->ReleasePort ( fClientControl.fRefNum, fPlaybackPortList[audio_port_index] );
00353 for ( midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++ )
00354 fGraphManager->ReleasePort ( fClientControl.fRefNum, fMidiCapturePortList[midi_port_index] );
00355 for ( midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++ )
00356 fGraphManager->ReleasePort ( fClientControl.fRefNum, fMidiPlaybackPortList[midi_port_index] );
00357 return 0;
00358 }
00359
00360 JackMidiBuffer* JackNetDriver::GetMidiInputBuffer ( int port_index )
00361 {
00362 return static_cast<JackMidiBuffer*> ( fGraphManager->GetBuffer ( fMidiCapturePortList[port_index], fEngineControl->fBufferSize ) );
00363 }
00364
00365 JackMidiBuffer* JackNetDriver::GetMidiOutputBuffer ( int port_index )
00366 {
00367 return static_cast<JackMidiBuffer*> ( fGraphManager->GetBuffer ( fMidiPlaybackPortList[port_index], fEngineControl->fBufferSize ) );
00368 }
00369
00370
00371 int JackNetDriver::DecodeTransportData()
00372 {
00373
00374
00375
00376
00377 int refnum;
00378 bool conditional;
00379 if ( fSendTransportData.fTimebaseMaster == TIMEBASEMASTER )
00380 {
00381 fEngineControl->fTransport.GetTimebaseMaster ( refnum, conditional );
00382 if ( refnum != -1 )
00383 fEngineControl->fTransport.ResetTimebase ( refnum );
00384 jack_info ( "The NetMaster is now the new timebase master." );
00385 }
00386
00387
00388 if ( fSendTransportData.fNewState && ( fSendTransportData.fState != fEngineControl->fTransport.GetState() ) )
00389 {
00390 switch ( fSendTransportData.fState )
00391 {
00392 case JackTransportStopped :
00393 fEngineControl->fTransport.SetCommand ( TransportCommandStop );
00394 jack_info ( "Master stops transport." );
00395 break;
00396
00397 case JackTransportStarting :
00398 fEngineControl->fTransport.RequestNewPos ( &fSendTransportData.fPosition );
00399 fEngineControl->fTransport.SetCommand ( TransportCommandStart );
00400 jack_info ( "Master starts transport." );
00401 break;
00402
00403 case JackTransportRolling :
00404 fEngineControl->fTransport.SetState ( JackTransportRolling );
00405 jack_info ( "Master is rolling." );
00406 break;
00407 }
00408 }
00409
00410 return 0;
00411 }
00412
00413 int JackNetDriver::EncodeTransportData()
00414 {
00415
00416 int refnum;
00417 bool conditional;
00418 fEngineControl->fTransport.GetTimebaseMaster ( refnum, conditional );
00419 if ( refnum != fLastTimebaseMaster )
00420 {
00421
00422 if ( refnum == -1 )
00423 {
00424 fReturnTransportData.fTimebaseMaster = RELEASE_TIMEBASEMASTER;
00425 jack_info ( "Sending a timebase master release request." );
00426 }
00427
00428 else
00429 {
00430 fReturnTransportData.fTimebaseMaster = ( conditional ) ? CONDITIONAL_TIMEBASEMASTER : TIMEBASEMASTER;
00431 jack_info ( "Sending a %s timebase master request.", ( conditional ) ? "conditional" : "non-conditional" );
00432 }
00433 fLastTimebaseMaster = refnum;
00434 }
00435 else
00436 fReturnTransportData.fTimebaseMaster = NO_CHANGE;
00437
00438
00439 fReturnTransportData.fState = fEngineControl->fTransport.Query ( &fReturnTransportData.fPosition );
00440
00441
00442 fReturnTransportData.fNewState = ( ( fReturnTransportData.fState != fLastTransportState ) &&
00443 ( fReturnTransportData.fState != fSendTransportData.fState ) );
00444 if ( fReturnTransportData.fNewState )
00445 jack_info ( "Sending '%s'.", GetTransportState ( fReturnTransportData.fState ) );
00446 fLastTransportState = fReturnTransportData.fState;
00447
00448 return 0;
00449 }
00450
00451
00452 int JackNetDriver::DecodeSyncPacket()
00453 {
00454
00455
00456 if ( fParams.fTransportSync )
00457 {
00458
00459 memcpy ( &fSendTransportData, fRxData, sizeof ( net_transport_data_t ) );
00460 if ( DecodeTransportData() < 0 )
00461 return -1;
00462 }
00463
00464
00465 return 0;
00466 }
00467
00468 int JackNetDriver::EncodeSyncPacket()
00469 {
00470
00471
00472 memset ( fTxData, 0, fPayloadSize );
00473
00474 if ( fParams.fTransportSync )
00475 {
00476 if ( EncodeTransportData() < 0 )
00477 return -1;
00478
00479 memcpy ( fTxData, &fReturnTransportData, sizeof ( net_transport_data_t ) );
00480 }
00481
00482
00483 return 0;
00484 }
00485
00486
00487 int JackNetDriver::Read()
00488 {
00489 uint midi_port_index;
00490 uint audio_port_index;
00491
00492
00493 for ( midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++ )
00494 fNetMidiCaptureBuffer->SetBuffer ( midi_port_index, GetMidiInputBuffer ( midi_port_index ) );
00495 for ( audio_port_index = 0; audio_port_index < fParams.fSendAudioChannels; audio_port_index++ )
00496 fNetAudioCaptureBuffer->SetBuffer ( audio_port_index, GetInputBuffer ( audio_port_index ) );
00497
00498 #ifdef JACK_MONITOR
00499 fNetTimeMon->New();
00500 #endif
00501
00502
00503 if ( SyncRecv() == SOCKET_ERROR )
00504 return 0;
00505
00506
00507 JackDriver::CycleTakeBeginTime();
00508
00509
00510
00511 if ( DecodeSyncPacket() < 0 )
00512 return 0;
00513
00514 #ifdef JACK_MONITOR
00515 fNetTimeMon->Add ( ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f );
00516 #endif
00517
00518 if ( DataRecv() == SOCKET_ERROR )
00519 return SOCKET_ERROR;
00520
00521 #ifdef JACK_MONITOR
00522 fNetTimeMon->Add ( ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f );
00523 #endif
00524
00525 return 0;
00526 }
00527
00528 int JackNetDriver::Write()
00529 {
00530 uint midi_port_index;
00531 int audio_port_index;
00532
00533
00534 for ( midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++ )
00535 fNetMidiPlaybackBuffer->SetBuffer ( midi_port_index, GetMidiOutputBuffer ( midi_port_index ) );
00536 for ( audio_port_index = 0; audio_port_index < fPlaybackChannels; audio_port_index++ )
00537 fNetAudioPlaybackBuffer->SetBuffer ( audio_port_index, GetOutputBuffer ( audio_port_index ) );
00538
00539 #ifdef JACK_MONITOR
00540 fNetTimeMon->Add ( ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f );
00541 #endif
00542
00543
00544 if ( EncodeSyncPacket() < 0 )
00545 return 0;
00546
00547
00548 if ( SyncSend() == SOCKET_ERROR )
00549 return SOCKET_ERROR;
00550
00551 #ifdef JACK_MONITOR
00552 fNetTimeMon->Add ( ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f );
00553 #endif
00554
00555
00556 if ( DataSend() == SOCKET_ERROR )
00557 return SOCKET_ERROR;
00558
00559 #ifdef JACK_MONITOR
00560 fNetTimeMon->AddLast ( ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f );
00561 #endif
00562
00563 return 0;
00564 }
00565
00566
00567
00568 #ifdef __cplusplus
00569 extern "C"
00570 {
00571 #endif
00572 SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor ()
00573 {
00574 jack_driver_desc_t* desc = ( jack_driver_desc_t* ) calloc ( 1, sizeof ( jack_driver_desc_t ) );
00575
00576 strcpy ( desc->name, "net" );
00577 strcpy ( desc->desc, "netjack slave backend component" );
00578
00579 desc->nparams = 10;
00580 desc->params = ( jack_driver_param_desc_t* ) calloc ( desc->nparams, sizeof ( jack_driver_param_desc_t ) );
00581
00582 int i = 0;
00583 strcpy ( desc->params[i].name, "multicast_ip" );
00584 desc->params[i].character = 'a';
00585 desc->params[i].type = JackDriverParamString;
00586 strcpy ( desc->params[i].value.str, DEFAULT_MULTICAST_IP );
00587 strcpy ( desc->params[i].short_desc, "Multicast Address" );
00588 strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );
00589
00590 i++;
00591 strcpy ( desc->params[i].name, "udp_net_port" );
00592 desc->params[i].character = 'p';
00593 desc->params[i].type = JackDriverParamInt;
00594 desc->params[i].value.i = 19000;
00595 strcpy ( desc->params[i].short_desc, "UDP port" );
00596 strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );
00597
00598 i++;
00599 strcpy ( desc->params[i].name, "mtu" );
00600 desc->params[i].character = 'M';
00601 desc->params[i].type = JackDriverParamInt;
00602 desc->params[i].value.i = 1500;
00603 strcpy ( desc->params[i].short_desc, "MTU to the master" );
00604 strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );
00605
00606 i++;
00607 strcpy ( desc->params[i].name, "input_ports" );
00608 desc->params[i].character = 'C';
00609 desc->params[i].type = JackDriverParamInt;
00610 desc->params[i].value.i = 2;
00611 strcpy ( desc->params[i].short_desc, "Number of audio input ports" );
00612 strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );
00613
00614 i++;
00615 strcpy ( desc->params[i].name, "output_ports" );
00616 desc->params[i].character = 'P';
00617 desc->params[i].type = JackDriverParamInt;
00618 desc->params[i].value.i = 2;
00619 strcpy ( desc->params[i].short_desc, "Number of audio output ports" );
00620 strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );
00621
00622 i++;
00623 strcpy ( desc->params[i].name, "midi_in_ports" );
00624 desc->params[i].character = 'i';
00625 desc->params[i].type = JackDriverParamInt;
00626 desc->params[i].value.i = 0;
00627 strcpy ( desc->params[i].short_desc, "Number of midi input ports" );
00628 strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );
00629
00630 i++;
00631 strcpy ( desc->params[i].name, "midi_out_ports" );
00632 desc->params[i].character = 'o';
00633 desc->params[i].type = JackDriverParamUInt;
00634 desc->params[i].value.i = 0;
00635 strcpy ( desc->params[i].short_desc, "Number of midi output ports" );
00636 strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );
00637
00638 i++;
00639 strcpy ( desc->params[i].name, "client_name" );
00640 desc->params[i].character = 'n';
00641 desc->params[i].type = JackDriverParamString;
00642 strcpy ( desc->params[i].value.str, "'hostname'" );
00643 strcpy ( desc->params[i].short_desc, "Name of the jack client" );
00644 strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );
00645
00646 i++;
00647 strcpy ( desc->params[i].name, "transport_sync" );
00648 desc->params[i].character = 't';
00649 desc->params[i].type = JackDriverParamUInt;
00650 desc->params[i].value.ui = 1U;
00651 strcpy ( desc->params[i].short_desc, "Sync transport with master's" );
00652 strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );
00653
00654 i++;
00655 strcpy ( desc->params[i].name, "mode" );
00656 desc->params[i].character = 'm';
00657 desc->params[i].type = JackDriverParamString;
00658 strcpy ( desc->params[i].value.str, "normal" );
00659 strcpy ( desc->params[i].short_desc, "Slow, Normal or Fast mode." );
00660 strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );
00661
00662 return desc;
00663 }
00664
00665 SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize ( Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params )
00666 {
00667 char multicast_ip[16];
00668 strcpy ( multicast_ip, DEFAULT_MULTICAST_IP );
00669 char net_name[JACK_CLIENT_NAME_SIZE];
00670 int udp_port = DEFAULT_PORT;
00671 int mtu = 1500;
00672 uint transport_sync = 1;
00673 jack_nframes_t period_size = 128;
00674 jack_nframes_t sample_rate = 48000;
00675 int audio_capture_ports = 2;
00676 int audio_playback_ports = 2;
00677 int midi_input_ports = 0;
00678 int midi_output_ports = 0;
00679 bool monitor = false;
00680 char network_mode = 'n';
00681 const JSList* node;
00682 const jack_driver_param_t* param;
00683
00684 net_name[0] = 0;
00685
00686 for ( node = params; node; node = jack_slist_next ( node ) )
00687 {
00688 param = ( const jack_driver_param_t* ) node->data;
00689 switch ( param->character )
00690 {
00691 case 'a' :
00692 strncpy ( multicast_ip, param->value.str, 15 );
00693 break;
00694 case 'p':
00695 udp_port = param->value.ui;
00696 break;
00697 case 'M':
00698 mtu = param->value.i;
00699 break;
00700 case 'C':
00701 audio_capture_ports = param->value.i;
00702 break;
00703 case 'P':
00704 audio_playback_ports = param->value.i;
00705 break;
00706 case 'i':
00707 midi_input_ports = param->value.i;
00708 break;
00709 case 'o':
00710 midi_output_ports = param->value.i;
00711 break;
00712 case 'n' :
00713 strncpy ( net_name, param->value.str, JACK_CLIENT_NAME_SIZE );
00714 break;
00715 case 't' :
00716 transport_sync = param->value.ui;
00717 break;
00718 case 'm' :
00719 if ( strcmp ( param->value.str, "normal" ) == 0 )
00720 network_mode = 'n';
00721 else if ( strcmp ( param->value.str, "slow" ) == 0 )
00722 network_mode = 's';
00723 else if ( strcmp ( param->value.str, "fast" ) == 0 )
00724 network_mode = 'f';
00725 else
00726 jack_error ( "Unknown network mode, using 'normal' mode." );
00727 break;
00728 }
00729 }
00730
00731 try
00732 {
00733
00734 Jack::JackDriverClientInterface* driver =
00735 new Jack::JackWaitThreadedDriver (
00736 new Jack::JackNetDriver ( "system", "net_pcm", engine, table, multicast_ip, udp_port, mtu,
00737 midi_input_ports, midi_output_ports, net_name, transport_sync, network_mode ) );
00738 if ( driver->Open ( period_size, sample_rate, 1, 1, audio_capture_ports, audio_playback_ports,
00739 monitor, "from_master_", "to_master_", 0, 0 ) == 0 )
00740 {
00741 return driver;
00742 }
00743 else
00744 {
00745 delete driver;
00746 return NULL;
00747 }
00748
00749 }
00750 catch ( ... )
00751 {
00752 return NULL;
00753 }
00754 }
00755
00756 #ifdef __cplusplus
00757 }
00758 #endif
00759 }