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