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