jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1190 Commits
8 Branches
255MB
Tree: edb638d77d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'edb638d77d'
${ noResults }
jack2/common/JackNetDriver.cpp

587 lines
24KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2001 Paul Davis

  3. Copyright (C) 2008 Romain Moret at Grame

  4. 

  5. This program is free software; you can redistribute it and/or modify

  6. it under the terms of the GNU General Public License as published by

  7. the Free Software Foundation; either version 2 of the License, or

  8. (at your option) any later version.

  9. 

  10. This program is distributed in the hope that it will be useful,

  11. but WITHOUT ANY WARRANTY; without even the implied warranty of

  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13. GNU General Public License for more details.

  14. 

  15. You should have received a copy of the GNU General Public License

  16. along with this program; if not, write to the Free Software

  17. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  18. 

  19. */

  20. 

  21. #include "JackNetDriver.h"

  22. #include "JackEngineControl.h"

  23. #include "JackClientControl.h"

  24. #include "JackGraphManager.h"

  25. #include "JackDriverLoader.h"

  26. #include "JackThreadedDriver.h"

  27. #include "JackWaitThreadedDriver.h"

  28. 

  29. #define DEFAULT_MULTICAST_IP "225.3.19.154"

  30. #define DEFAULT_PORT 19000

  31. 

  32. using namespace std;

  33. 

  34. namespace Jack

  35. {

  36.     JackNetDriver::JackNetDriver ( const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table,

  37.                                    const char* ip, int port, int mtu, int midi_input_ports, int midi_output_ports,

  38.                                    const char* net_name, uint transport_sync, char network_mode )

  39.             : JackAudioDriver ( name, alias, engine, table ), JackNetSlaveInterface ( ip, port )

  40.     {

  41.         jack_log ( "JackNetDriver::JackNetDriver ip %s, port %d", ip, port );

  42. 

  43.         fParams.fMtu = mtu;

  44.         fParams.fSendMidiChannels = midi_input_ports;

  45.         fParams.fReturnMidiChannels = midi_output_ports;

  46.         strcpy ( fParams.fName, net_name );

  47.         fSocket.GetName ( fParams.fSlaveNetName );

  48.         fParams.fTransportSync = transport_sync;

  49.         fParams.fNetworkMode = network_mode;

  50. #ifdef JACK_MONITOR

  51.         fNetTimeMon = NULL;

  52. #endif

  53.     }

  54. 

  55.     JackNetDriver::~JackNetDriver()

  56.     {

  57.         delete[] fMidiCapturePortList;

  58.         delete[] fMidiPlaybackPortList;

  59. #ifdef JACK_MONITOR

  60.         delete fNetTimeMon;

  61. #endif

  62.     }

  63. 

  64. //*************************************initialization***********************************************************************

  65. 

  66.     int JackNetDriver::Open ( jack_nframes_t buffer_size, jack_nframes_t samplerate, bool capturing, bool playing,

  67.                               int inchannels, int outchannels, bool monitor,

  68.                               const char* capture_driver_name, const char* playback_driver_name,

  69.                               jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  70.     {

  71.         int res = JackAudioDriver::Open ( buffer_size, samplerate, capturing, playing, inchannels, outchannels, monitor,

  72.                                           capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  73.         fEngineControl->fPeriod = 0;

  74.         fEngineControl->fComputation = 500 * 1000;

  75.         fEngineControl->fConstraint = 500 * 1000;

  76.         return res;

  77.     }

  78. 

  79. #ifdef JACK_MONITOR

  80.     int JackNetDriver::Close()

  81.     {

  82.         if ( fNetTimeMon )

  83.             fNetTimeMon->Save();

  84.         return JackDriver::Close();

  85.     }

  86. #endif

  87. 

  88.     int JackNetDriver::Attach()

  89.     {

  90.         return 0;

  91.     }

  92. 

  93.     int JackNetDriver::Detach()

  94.     {

  95.         return 0;

  96.     }

  97. 

  98.     bool JackNetDriver::Init()

  99.     {

  100.         jack_log ( "JackNetDriver::Init()" );

  101. 

  102.         //new loading, but existing socket, restart the driver

  103.         if ( fSocket.IsSocket() )

  104.             Restart();

  105. 

  106.         //set the parameters to send

  107.         fParams.fSendAudioChannels = fCaptureChannels;

  108.         fParams.fReturnAudioChannels = fPlaybackChannels;

  109.         fParams.fSlaveSyncMode = fEngineControl->fSyncMode;

  110. 

  111.         //display some additional infos

  112.         jack_info ( "Net driver started in %s mode %s Master's transport sync.",

  113.                     ( fParams.fSlaveSyncMode ) ? "sync" : "async", ( fParams.fTransportSync ) ? "with" : "without" );

  114. 

  115.         //init network

  116.         if ( !JackNetSlaveInterface::Init() )

  117.             return false;;

  118. 

  119.         //set global paramaters

  120.         SetParams();

  121. 

  122.         //driver parametering

  123.         JackAudioDriver::SetBufferSize ( fParams.fPeriodSize );

  124.         JackAudioDriver::SetSampleRate ( fParams.fSampleRate );

  125. 

  126.         JackDriver::NotifyBufferSize ( fParams.fPeriodSize );

  127.         JackDriver::NotifySampleRate ( fParams.fSampleRate );

  128. 

  129.         //allocate midi ports lists

  130.         fMidiCapturePortList = new jack_port_id_t [fParams.fSendMidiChannels];

  131.         fMidiPlaybackPortList = new jack_port_id_t [fParams.fReturnMidiChannels];

  132. 

  133.         //register jack ports

  134.         if ( AllocPorts() != 0 )

  135.         {

  136.             jack_error ( "Can't allocate ports." );

  137.             return false;

  138.         }

  139. 

  140.         //init done, display parameters

  141.         SessionParamsDisplay ( &fParams );

  142. 

  143.         //monitor

  144. #ifdef JACK_MONITOR

  145.         string plot_name;

  146.         //NetTimeMon

  147.         plot_name = string ( fParams.fName );

  148.         plot_name += string ( "_slave" );

  149.         plot_name += ( fEngineControl->fSyncMode ) ? string ( "_sync" ) : string ( "_async" );

  150.         switch ( fParams.fNetworkMode )

  151.         {

  152.             case 's' :

  153.                 plot_name += string ( "_slow" );

  154.                 break;

  155.             case 'n' :

  156.                 plot_name += string ( "_normal" );

  157.                 break;

  158.             case 'f' :

  159.                 plot_name += string ( "_fast" );

  160.                 break;

  161.         }

  162.         fNetTimeMon = new JackGnuPlotMonitor<float> ( 128, 4, plot_name );

  163.         string net_time_mon_fields[] =

  164.         {

  165.             string ( "end of read" ),

  166.             string ( "start of write" ),

  167.             string ( "sync send" ),

  168.             string ( "end of write" )

  169.         };

  170.         string net_time_mon_options[] =

  171.         {

  172.             string ( "set xlabel \"audio cycles\"" ),

  173.             string ( "set ylabel \"% of audio cycle\"" )

  174.         };

  175.         fNetTimeMon->SetPlotFile ( net_time_mon_options, 2, net_time_mon_fields, 4 );

  176. #endif

  177. 

  178.         return true;

  179.     }

  180. 

  181.     void JackNetDriver::Restart()

  182.     {

  183.         jack_log ( "JackNetDriver::Restart" );

  184. 

  185.         jack_info ( "Restarting driver..." );

  186.         delete[] fTxBuffer;

  187.         fTxBuffer = NULL;

  188.         delete[] fRxBuffer;

  189.         fRxBuffer = NULL;

  190.         delete fNetAudioCaptureBuffer;

  191.         fNetAudioCaptureBuffer = NULL;

  192.         delete fNetAudioPlaybackBuffer;

  193.         fNetAudioPlaybackBuffer = NULL;

  194.         delete fNetMidiCaptureBuffer;

  195.         fNetMidiCaptureBuffer = NULL;

  196.         delete fNetMidiPlaybackBuffer;

  197.         fNetMidiPlaybackBuffer = NULL;

  198.         FreePorts();

  199.         delete[] fMidiCapturePortList;

  200.         fMidiCapturePortList = NULL;

  201.         delete[] fMidiPlaybackPortList;

  202.         fMidiPlaybackPortList = NULL;

  203. #ifdef JACK_MONITOR

  204.         delete fNetTimeMon;

  205.         fNetTimeMon = NULL;

  206. #endif

  207.     }

  208. 

  209.     int JackNetDriver::AllocPorts()

  210.     {

  211.         jack_log ( "JackNetDriver::AllocPorts fBufferSize = %ld fSampleRate = %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate );

  212. 

  213.         JackPort* port;

  214.         jack_port_id_t port_id;

  215.         char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  216.         char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  217.         unsigned long port_flags;

  218.         int audio_port_index;

  219.         uint midi_port_index;

  220. 

  221.         //audio

  222.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  223.         for ( audio_port_index = 0; audio_port_index < fCaptureChannels; audio_port_index++ )

  224.         {

  225.             snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:out%d", fAliasName, fCaptureDriverName, audio_port_index + 1 );

  226.             snprintf ( name, sizeof ( name ) - 1, "%s:capture_%d", fClientControl.fName, audio_port_index + 1 );

  227.             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE,

  228.                              static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )

  229.             {

  230.                 jack_error ( "driver: cannot register port for %s", name );

  231.                 return -1;

  232.             }

  233.             port = fGraphManager->GetPort ( port_id );

  234.             port->SetAlias ( alias );

  235.             port->SetLatency ( fEngineControl->fBufferSize );

  236.             fCapturePortList[audio_port_index] = port_id;

  237.             jack_log ( "JackNetDriver::AllocPorts() fCapturePortList[%d] audio_port_index = %ld fPortLatency = %ld", audio_port_index, port_id, port->GetLatency() );

  238.         }

  239.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  240.         for ( audio_port_index = 0; audio_port_index < fPlaybackChannels; audio_port_index++ )

  241.         {

  242.             snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:in%d", fAliasName, fPlaybackDriverName, audio_port_index + 1 );

  243.             snprintf ( name, sizeof ( name ) - 1, "%s:playback_%d",fClientControl.fName, audio_port_index + 1 );

  244.             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE,

  245.                              static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )

  246.             {

  247.                 jack_error ( "driver: cannot register port for %s", name );

  248.                 return -1;

  249.             }

  250.             port = fGraphManager->GetPort ( port_id );

  251.             port->SetAlias ( alias );

  252.             port->SetLatency ( ( fParams.fNetworkMode == 'f' ) ? 0 : fEngineControl->fBufferSize + ( ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize ) );

  253.             fPlaybackPortList[audio_port_index] = port_id;

  254.             jack_log ( "JackNetDriver::AllocPorts() fPlaybackPortList[%d] audio_port_index = %ld fPortLatency = %ld", audio_port_index, port_id, port->GetLatency() );

  255.         }

  256.         //midi

  257.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  258.         for ( midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++ )

  259.         {

  260.             snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:out%d", fAliasName, fCaptureDriverName, midi_port_index + 1 );

  261.             snprintf ( name, sizeof ( name ) - 1, "%s:midi_capture_%d", fClientControl.fName, midi_port_index + 1 );

  262.             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_MIDI_TYPE,

  263.                              static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )

  264.             {

  265.                 jack_error ( "driver: cannot register port for %s", name );

  266.                 return -1;

  267.             }

  268.             port = fGraphManager->GetPort ( port_id );

  269.             port->SetLatency ( fEngineControl->fBufferSize );

  270.             fMidiCapturePortList[midi_port_index] = port_id;

  271.             jack_log ( "JackNetDriver::AllocPorts() fMidiCapturePortList[%d] midi_port_index = %ld fPortLatency = %ld", midi_port_index, port_id, port->GetLatency() );

  272.         }

  273. 

  274.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  275.         for ( midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++ )

  276.         {

  277.             snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:in%d", fAliasName, fPlaybackDriverName, midi_port_index + 1 );

  278.             snprintf ( name, sizeof ( name ) - 1, "%s:midi_playback_%d", fClientControl.fName, midi_port_index + 1 );

  279.             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_MIDI_TYPE,

  280.                              static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )

  281.             {

  282.                 jack_error ( "driver: cannot register port for %s", name );

  283.                 return -1;

  284.             }

  285.             port = fGraphManager->GetPort ( port_id );

  286.             port->SetLatency ( ( fParams.fNetworkMode == 'f' ) ? 0 : fEngineControl->fBufferSize + ( ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize ) );

  287.             fMidiPlaybackPortList[midi_port_index] = port_id;

  288.             jack_log ( "JackNetDriver::AllocPorts() fMidiPlaybackPortList[%d] midi_port_index = %ld fPortLatency = %ld", midi_port_index, port_id, port->GetLatency() );

  289.         }

  290. 

  291.         return 0;

  292.     }

  293. 

  294.     int JackNetDriver::FreePorts()

  295.     {

  296.         jack_log ( "JackNetDriver::FreePorts" );

  297. 

  298.         int audio_port_index;

  299.         uint midi_port_index;

  300.         for ( audio_port_index = 0; audio_port_index < fCaptureChannels; audio_port_index++ )

  301.             fGraphManager->ReleasePort ( fClientControl.fRefNum, fCapturePortList[audio_port_index] );

  302.         for ( audio_port_index = 0; audio_port_index < fPlaybackChannels; audio_port_index++ )

  303.             fGraphManager->ReleasePort ( fClientControl.fRefNum, fPlaybackPortList[audio_port_index] );

  304.         for ( midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++ )

  305.             fGraphManager->ReleasePort ( fClientControl.fRefNum, fMidiCapturePortList[midi_port_index] );

  306.         for ( midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++ )

  307.             fGraphManager->ReleasePort ( fClientControl.fRefNum, fMidiPlaybackPortList[midi_port_index] );

  308.         return 0;

  309.     }

  310. 

  311.     JackMidiBuffer* JackNetDriver::GetMidiInputBuffer ( int port_index )

  312.     {

  313.         return static_cast<JackMidiBuffer*> ( fGraphManager->GetBuffer ( fMidiCapturePortList[port_index], fEngineControl->fBufferSize ) );

  314.     }

  315. 

  316.     JackMidiBuffer* JackNetDriver::GetMidiOutputBuffer ( int port_index )

  317.     {

  318.         return static_cast<JackMidiBuffer*> ( fGraphManager->GetBuffer ( fMidiPlaybackPortList[port_index], fEngineControl->fBufferSize ) );

  319.     }

  320. 

  321.     int JackNetDriver::SetSyncPacket()

  322.     {

  323.         if ( fParams.fTransportSync )

  324.         {

  325.             //set the TransportData

  326. 

  327.             //copy to TxBuffer

  328.             memcpy ( fTxData, &fTransportData, sizeof ( net_transport_data_t ) );

  329.         }

  330.         return 0;

  331.     }

  332. 

  333. //*************************************process************************************************************************

  334. 

  335.     int JackNetDriver::Read()

  336.     {

  337.         uint midi_port_index;

  338.         uint audio_port_index;

  339. 

  340.         //buffers

  341.         for ( midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++ )

  342.             fNetMidiCaptureBuffer->SetBuffer ( midi_port_index, GetMidiInputBuffer ( midi_port_index ) );

  343.         for ( audio_port_index = 0; audio_port_index < fParams.fSendAudioChannels; audio_port_index++ )

  344.             fNetAudioCaptureBuffer->SetBuffer ( audio_port_index, GetInputBuffer ( audio_port_index ) );

  345. 

  346. #ifdef JACK_MONITOR

  347.         fNetTimeMon->New();

  348. #endif

  349. 

  350.         //receive sync (launch the cycle)

  351.         if ( SyncRecv() == SOCKET_ERROR )

  352.             return 0;

  353. 

  354.         //take the time at the beginning of the cycle

  355.         JackDriver::CycleTakeBeginTime();

  356. 

  357.         //audio, midi or sync if driver is late

  358.         if ( DataRecv() == SOCKET_ERROR )

  359.             return SOCKET_ERROR;

  360. 

  361. #ifdef JACK_MONITOR

  362.         fNetTimeMon->Add ( ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f );

  363. #endif

  364. 

  365.         return 0;

  366.     }

  367. 

  368.     int JackNetDriver::Write()

  369.     {

  370.         uint midi_port_index;

  371.         int audio_port_index;

  372. 

  373.         //buffers

  374.         for ( midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++ )

  375.             fNetMidiPlaybackBuffer->SetBuffer ( midi_port_index, GetMidiOutputBuffer ( midi_port_index ) );

  376.         for ( audio_port_index = 0; audio_port_index < fPlaybackChannels; audio_port_index++ )

  377.             fNetAudioPlaybackBuffer->SetBuffer ( audio_port_index, GetOutputBuffer ( audio_port_index ) );

  378. 

  379. #ifdef JACK_MONITOR

  380.         fNetTimeMon->Add ( ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f );

  381. #endif

  382. 

  383.         //sync

  384.         memset ( fTxData, 0, fPayloadSize );

  385.         SetSyncPacket();

  386. 

  387.         //send sync

  388.         if ( SyncSend() == SOCKET_ERROR )

  389.             return SOCKET_ERROR;

  390. 

  391. #ifdef JACK_MONITOR

  392.         fNetTimeMon->Add ( ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f );

  393. #endif

  394. 

  395.         //send data

  396.         if ( DataSend() == SOCKET_ERROR )

  397.             return SOCKET_ERROR;

  398. 

  399. #ifdef JACK_MONITOR

  400.         fNetTimeMon->AddLast ( ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f );

  401. #endif

  402. 

  403.         return 0;

  404.     }

  405. 

  406. //*************************************loader*******************************************************

  407. 

  408. #ifdef __cplusplus

  409.     extern "C"

  410.     {

  411. #endif

  412.         EXPORT jack_driver_desc_t* driver_get_descriptor ()

  413.         {

  414.             jack_driver_desc_t* desc = ( jack_driver_desc_t* ) calloc ( 1, sizeof ( jack_driver_desc_t ) );

  415.             strcpy ( desc->name, "net" );

  416.             desc->nparams = 10;

  417.             desc->params = ( jack_driver_param_desc_t* ) calloc ( desc->nparams, sizeof ( jack_driver_param_desc_t ) );

  418. 

  419.             int i = 0;

  420.             strcpy ( desc->params[i].name, "multicast_ip" );

  421.             desc->params[i].character = 'a';

  422.             desc->params[i].type = JackDriverParamString;

  423.             strcpy ( desc->params[i].value.str, DEFAULT_MULTICAST_IP );

  424.             strcpy ( desc->params[i].short_desc, "Multicast Address" );

  425.             strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  426. 

  427.             i++;

  428.             strcpy ( desc->params[i].name, "udp_net_port" );

  429.             desc->params[i].character = 'p';

  430.             desc->params[i].type = JackDriverParamInt;

  431.             desc->params[i].value.i = 19000;

  432.             strcpy ( desc->params[i].short_desc, "UDP port" );

  433.             strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  434. 

  435.             i++;

  436.             strcpy ( desc->params[i].name, "mtu" );

  437.             desc->params[i].character = 'M';

  438.             desc->params[i].type = JackDriverParamInt;

  439.             desc->params[i].value.i = 1500;

  440.             strcpy ( desc->params[i].short_desc, "MTU to the master" );

  441.             strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  442. 

  443.             i++;

  444.             strcpy ( desc->params[i].name, "input_ports" );

  445.             desc->params[i].character = 'C';

  446.             desc->params[i].type = JackDriverParamInt;

  447.             desc->params[i].value.i = 2;

  448.             strcpy ( desc->params[i].short_desc, "Number of audio input ports" );

  449.             strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  450. 

  451.             i++;

  452.             strcpy ( desc->params[i].name, "output_ports" );

  453.             desc->params[i].character = 'P';

  454.             desc->params[i].type = JackDriverParamInt;

  455.             desc->params[i].value.i = 2;

  456.             strcpy ( desc->params[i].short_desc, "Number of audio output ports" );

  457.             strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  458. 

  459.             i++;

  460.             strcpy ( desc->params[i].name, "midi_in_ports" );

  461.             desc->params[i].character = 'i';

  462.             desc->params[i].type = JackDriverParamInt;

  463.             desc->params[i].value.i = 0;

  464.             strcpy ( desc->params[i].short_desc, "Number of midi input ports" );

  465.             strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  466. 

  467.             i++;

  468.             strcpy ( desc->params[i].name, "midi_out_ports" );

  469.             desc->params[i].character = 'o';

  470.             desc->params[i].type = JackDriverParamUInt;

  471.             desc->params[i].value.i = 0;

  472.             strcpy ( desc->params[i].short_desc, "Number of midi output ports" );

  473.             strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  474. 

  475.             i++;

  476.             strcpy ( desc->params[i].name, "client_name" );

  477.             desc->params[i].character = 'n';

  478.             desc->params[i].type = JackDriverParamString;

  479.             strcpy ( desc->params[i].value.str, "'hostname'" );

  480.             strcpy ( desc->params[i].short_desc, "Name of the jack client" );

  481.             strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  482. 

  483.             i++;

  484.             strcpy ( desc->params[i].name, "transport_sync" );

  485.             desc->params[i].character  = 't';

  486.             desc->params[i].type = JackDriverParamUInt;

  487.             desc->params[i].value.ui = 1U;

  488.             strcpy ( desc->params[i].short_desc, "Sync transport with master's" );

  489.             strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  490. 

  491.             i++;

  492.             strcpy ( desc->params[i].name, "mode" );

  493.             desc->params[i].character  = 'm';

  494.             desc->params[i].type = JackDriverParamString;

  495.             strcpy ( desc->params[i].value.str, "normal" );

  496.             strcpy ( desc->params[i].short_desc, "Slow, Normal or Fast mode." );

  497.             strcpy ( desc->params[i].long_desc, desc->params[i].short_desc );

  498. 

  499.             return desc;

  500.         }

  501. 

  502.         EXPORT Jack::JackDriverClientInterface* driver_initialize ( Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params )

  503.         {

  504.             if ( SocketAPIInit() < 0 )

  505.             {

  506.                 jack_error ( "Can't init Socket API, exiting..." );

  507.                 return NULL;

  508.             }

  509.             char multicast_ip[16];

  510.             strcpy ( multicast_ip, DEFAULT_MULTICAST_IP );

  511.             char name[JACK_CLIENT_NAME_SIZE];

  512.             GetHostName ( name, JACK_CLIENT_NAME_SIZE );

  513.             int udp_port = DEFAULT_PORT;

  514.             int mtu = 1500;

  515.             uint transport_sync = 1;

  516.             jack_nframes_t period_size = 128;

  517.             jack_nframes_t sample_rate = 48000;

  518.             int audio_capture_ports = 2;

  519.             int audio_playback_ports = 2;

  520.             int midi_input_ports = 0;

  521.             int midi_output_ports = 0;

  522.             bool monitor = false;

  523.             char network_mode = 'n';

  524. 

  525.             const JSList* node;

  526.             const jack_driver_param_t* param;

  527.             for ( node = params; node; node = jack_slist_next ( node ) )

  528.             {

  529.                 param = ( const jack_driver_param_t* ) node->data;

  530.                 switch ( param->character )

  531.                 {

  532.                     case 'a' :

  533.                         strncpy ( multicast_ip, param->value.str, 15 );

  534.                         break;

  535.                     case 'p':

  536.                         udp_port = param->value.ui;

  537.                         break;

  538.                     case 'M':

  539.                         mtu = param->value.i;

  540.                         break;

  541.                     case 'C':

  542.                         audio_capture_ports = param->value.i;

  543.                         break;

  544.                     case 'P':

  545.                         audio_playback_ports = param->value.i;

  546.                         break;

  547.                     case 'i':

  548.                         midi_input_ports = param->value.i;

  549.                         break;

  550.                     case 'o':

  551.                         midi_output_ports = param->value.i;

  552.                         break;

  553.                     case 'n' :

  554.                         strncpy ( name, param->value.str, JACK_CLIENT_NAME_SIZE );

  555.                         break;

  556.                     case 't' :

  557.                         transport_sync = param->value.ui;

  558.                         break;

  559.                     case 'm' :

  560.                         if ( strcmp ( param->value.str, "normal" ) == 0 )

  561.                             network_mode = 'n';

  562.                         else if ( strcmp ( param->value.str, "slow" ) == 0 )

  563.                             network_mode = 's';

  564.                         else if ( strcmp ( param->value.str, "fast" ) == 0 )

  565.                             network_mode = 'f';

  566.                         else

  567.                             jack_error ( "Unknown network mode, using 'normal' mode." );

  568.                         break;

  569.                 }

  570.             }

  571. 

  572.             Jack::JackDriverClientInterface* driver = new Jack::JackWaitThreadedDriver (

  573.                 new Jack::JackNetDriver ( "system", "net_pcm", engine, table, multicast_ip, udp_port, mtu,

  574.                                           midi_input_ports, midi_output_ports, name, transport_sync, network_mode ) );

  575.             if ( driver->Open ( period_size, sample_rate, 1, 1, audio_capture_ports, audio_playback_ports,

  576.                                 monitor, "from_master_", "to_master_", 0, 0 ) == 0 )

  577.                 return driver;

  578. 

  579.             delete driver;

  580.             return NULL;

  581.         }

  582. 

  583. #ifdef __cplusplus

  584.     }

  585. #endif

  586. }