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.
1177 Commits
8 Branches
255MB
Tree: cc29f2c766
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cc29f2c766'
${ noResults }
jack2/common/JackNetDriver.cpp

595 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. #include "JackException.h"

  29. 

  30. #define DEFAULT_MULTICAST_IP "225.3.19.154"

  31. #define DEFAULT_PORT 19000

  32. 

  33. using namespace std;

  34. 

  35. namespace Jack

  36. {

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

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

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

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

  41.     {

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

  43. 

  44.         fMulticastIP = new char[strlen ( ip ) + 1];

  45.         strcpy ( fMulticastIP, ip );

  46.         fParams.fMtu = mtu;

  47.         fParams.fSendMidiChannels = midi_input_ports;

  48.         fParams.fReturnMidiChannels = midi_output_ports;

  49.         strcpy ( fParams.fName, net_name );

  50.         fSocket.GetName ( fParams.fSlaveNetName );

  51.         fParams.fTransportSync = transport_sync;

  52.         fParams.fNetworkMode = network_mode;

  53. #ifdef JACK_MONITOR

  54.         fNetTimeMon = NULL;

  55.         fCycleTimeMon = NULL;

  56. #endif

  57.     }

  58. 

  59.     JackNetDriver::~JackNetDriver()

  60.     {

  61.         fSocket.Close();

  62.         delete[] fMidiCapturePortList;

  63.         delete[] fMidiPlaybackPortList;

  64. #ifdef JACK_MONITOR

  65.         delete fNetTimeMon;

  66.         delete fCycleTimeMon;

  67. #endif

  68.     }

  69. 

  70. //*************************************initialization***********************************************************************

  71. 

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

  73.                               int inchannels, int outchannels, bool monitor,

  74.                               const char* capture_driver_name, const char* playback_driver_name,

  75.                               jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  76.     {

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

  78.                                           capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  79.         fEngineControl->fPeriod = 0;

  80.         fEngineControl->fComputation = 500 * 1000;

  81.         fEngineControl->fConstraint = 500 * 1000;

  82.         return res;

  83.     }

  84. 

  85. #ifdef JACK_MONITOR

  86.     int JackNetDriver::Close()

  87.     {

  88.         if ( fNetTimeMon )

  89.             fNetTimeMon->Save();

  90.         if ( fCycleTimeMon )

  91.             fCycleTimeMon->Save();

  92.         return JackDriver::Close();

  93.     }

  94. #endif

  95. 

  96.     int JackNetDriver::Attach()

  97.     {

  98.         return 0;

  99.     }

  100. 

  101.     int JackNetDriver::Detach()

  102.     {

  103.         return 0;

  104.     }

  105. 

  106.     bool JackNetDriver::Init()

  107.     {

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

  109. 

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

  111.         if ( fSocket.IsSocket() )

  112.             Restart();

  113. 

  114.         //set the parameters to send

  115.         fParams.fSendAudioChannels = fCaptureChannels;

  116.         fParams.fReturnAudioChannels = fPlaybackChannels;

  117.         fParams.fSlaveSyncMode = fEngineControl->fSyncMode;

  118. 

  119. 		//display some additional infos

  120. 		jack_info ( "NetAdapter started in %s mode %s Master's transport sync.",

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

  122. 

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

  124.             return false;;

  125. 

  126.         //driver parametering

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

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

  129. 

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

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

  132. 

  133.         //allocate midi ports lists

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

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

  136. 

  137. 		//register jack ports

  138.         if ( AllocPorts() != 0 )

  139.         {

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

  141.             return false;

  142.         }

  143. 

  144.         //set global paramaters

  145.         SetParams();

  146. 

  147.         //init done, display parameters

  148.         SessionParamsDisplay ( &fParams );

  149. 

  150.         //monitor

  151. #ifdef JACK_MONITOR

  152.         string plot_name;

  153.         //NetTimeMon

  154.         plot_name = string ( fParams.fName );

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

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

  157.         plot_name += ( fParams.fNetworkMode == 'f' ) ? string ( "_fast" ) : string ( "_normal" );

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

  159.         string net_time_mon_fields[] =

  160.         {

  161.             string ( "end of read" ),

  162.             string ( "start of write" ),

  163.             string ( "sync send" ),

  164.             string ( "end of write" )

  165.         };

  166.         string net_time_mon_options[] =

  167.         {

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

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

  170.         };

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

  172.         //CycleTimeMon

  173.         plot_name.clear();

  174.         plot_name = string ( fParams.fName );

  175.         plot_name += string ( "_slave_cycle_duration" );

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

  177.         plot_name += ( fParams.fNetworkMode == 'f' ) ? string ( "_fast" ) : string ( "_normal" );

  178.         fCycleTimeMon = new JackGnuPlotMonitor<jack_time_t> ( 2048, 1, plot_name );

  179.         string cycle_time_mon_field = string ( "cycle duration" );

  180.         string cycle_time_mon_options[] =

  181.         {

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

  183.             string ( "set ylabel \"usecs\"" )

  184.         };

  185.         fCycleTimeMon->SetPlotFile ( cycle_time_mon_options, 2, &cycle_time_mon_field, 1 );

  186.         fLastCycleBeginDate = GetMicroSeconds();

  187. #endif

  188. 

  189.         return true;

  190.     }

  191. 

  192.     void JackNetDriver::Restart()

  193.     {

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

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

  196.         delete[] fTxBuffer;

  197.         fTxBuffer = NULL;

  198.         delete[] fRxBuffer;

  199.         fRxBuffer = NULL;

  200.         delete fNetAudioCaptureBuffer;

  201.         fNetAudioCaptureBuffer = NULL;

  202.         delete fNetAudioPlaybackBuffer;

  203.         fNetAudioPlaybackBuffer = NULL;

  204.         delete fNetMidiCaptureBuffer;

  205.         fNetMidiCaptureBuffer = NULL;

  206.         delete fNetMidiPlaybackBuffer;

  207.         fNetMidiPlaybackBuffer = NULL;

  208.         FreePorts();

  209.         delete[] fMidiCapturePortList;

  210.         fMidiCapturePortList = NULL;

  211.         delete[] fMidiPlaybackPortList;

  212.         fMidiPlaybackPortList = NULL;

  213. #ifdef JACK_MONITOR

  214.         delete fNetTimeMon;

  215.         fNetTimeMon = NULL;

  216.         delete fCycleTimeMon;

  217.         fCycleTimeMon = NULL;

  218. #endif

  219.     }

  220. 

  221.     int JackNetDriver::AllocPorts()

  222.     {

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

  224.         JackPort* port;

  225.         jack_port_id_t port_id;

  226.         char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  227.         char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  228.         unsigned long port_flags;

  229.         int audio_port_index;

  230.         uint midi_port_index;

  231. 

  232.         //audio

  233.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  235.         {

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

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

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

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

  240.             {

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

  242.                 return -1;

  243.             }

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

  245.             port->SetAlias ( alias );

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

  247.             fCapturePortList[audio_port_index] = port_id;

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

  249.         }

  250.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  252.         {

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

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

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

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

  257.             {

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

  259.                 return -1;

  260.             }

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

  262.             port->SetAlias ( alias );

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

  264.             fPlaybackPortList[audio_port_index] = port_id;

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

  266.         }

  267.         //midi

  268.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  270.         {

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

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

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

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

  275.             {

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

  277.                 return -1;

  278.             }

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

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

  281.             fMidiCapturePortList[midi_port_index] = port_id;

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

  283.         }

  284. 

  285.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  287.         {

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

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

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

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

  292.             {

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

  294.                 return -1;

  295.             }

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

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

  298.             fMidiPlaybackPortList[midi_port_index] = port_id;

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

  300.         }

  301. 

  302.         return 0;

  303.     }

  304. 

  305.     int JackNetDriver::FreePorts()

  306.     {

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

  308.         int audio_port_index;

  309.         uint midi_port_index;

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

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

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

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

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

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

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

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

  318.         return 0;

  319.     }

  320. 

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

  322.     {

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

  324.     }

  325. 

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

  327.     {

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

  329.     }

  330. 

  331.     int JackNetDriver::SetSyncPacket()

  332.     {

  333.         if ( fParams.fTransportSync )

  334.         {

  335.             //set the TransportData

  336. 

  337.             //copy to TxBuffer

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

  339.         }

  340.         return 0;

  341.     }

  342. 

  343. //*************************************process************************************************************************

  344. 

  345.     int JackNetDriver::Read()

  346.     {

  347.         uint midi_port_index;

  348.         int audio_port_index;

  349. 

  350.         //buffers

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

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

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

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

  355. 

  356. #ifdef JACK_MONITOR

  357.         fNetTimeMon->New();

  358. #endif

  359. 

  360.         //receive sync (launch the cycle)

  361.         if ( SyncRecv() == SOCKET_ERROR )

  362.             return 0;

  363. 

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

  365.         JackDriver::CycleTakeBeginTime();

  366. 

  367. #ifdef JACK_MONITOR

  368.         fCycleTimeMon->AddNew ( JackDriver::fBeginDateUst - fLastCycleBeginDate );

  369.         fCycleTimeMon->Write();

  370.         fLastCycleBeginDate = JackDriver::fBeginDateUst;

  371. #endif

  372. 

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

  374.         if ( DataRecv() == SOCKET_ERROR )

  375.             return SOCKET_ERROR;

  376. 

  377. #ifdef JACK_MONITOR

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

  379. #endif

  380. 

  381.         return 0;

  382.     }

  383. 

  384.     int JackNetDriver::Write()

  385.     {

  386.         uint midi_port_index;

  387.         int audio_port_index;

  388. 

  389.         //buffers

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

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

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

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

  394. 

  395. #ifdef JACK_MONITOR

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

  397. #endif

  398. 

  399.         //sync

  400.         memset ( fTxData, 0, fPayloadSize );

  401.         SetSyncPacket();

  402. 

  403. 		//send sync

  404.         if ( SyncSend() == SOCKET_ERROR )

  405.             return SOCKET_ERROR;

  406. 

  407. #ifdef JACK_MONITOR

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

  409. #endif

  410. 

  411. 		//send data

  412.         if ( DataSend() == SOCKET_ERROR )

  413.             return SOCKET_ERROR;

  414. 

  415. #ifdef JACK_MONITOR

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

  417. #endif

  418. 

  419.         return 0;

  420.     }

  421. 

  422. //*************************************loader*******************************************************

  423. 

  424. #ifdef __cplusplus

  425.     extern "C"

  426.     {

  427. #endif

  428.         EXPORT jack_driver_desc_t* driver_get_descriptor ()

  429.         {

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

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

  432.             desc->nparams = 10;

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

  434. 

  435.             int i = 0;

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

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

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

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

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

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

  442. 

  443.             i++;

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

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

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

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

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

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

  450. 

  451.             i++;

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

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

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

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

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

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

  458. 

  459.             i++;

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

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

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

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

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

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

  466. 

  467.             i++;

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

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

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

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

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

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

  474. 

  475.             i++;

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

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

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

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

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

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

  482. 

  483.             i++;

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

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

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

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

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

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

  490. 

  491.             i++;

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

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

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

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

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

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

  498. 

  499.             i++;

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

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

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

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

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

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

  506. 

  507.             i++;

  508.             strcpy ( desc->params[i].name, "fast_mode" );

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

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

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

  512.             strcpy ( desc->params[i].short_desc, "Fast mode allows a zero latency transmission." );

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

  514. 

  515.             return desc;

  516.         }

  517. 

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

  519.         {

  520.             if ( SocketAPIInit() < 0 )

  521.             {

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

  523.                 return NULL;

  524.             }

  525.             const char* multicast_ip = DEFAULT_MULTICAST_IP;

  526.             char name[JACK_CLIENT_NAME_SIZE];

  527.             GetHostName ( name, JACK_CLIENT_NAME_SIZE );

  528.             int udp_port = DEFAULT_PORT;

  529.             int mtu = 1500;

  530.             uint transport_sync = 1;

  531.             jack_nframes_t period_size = 128;

  532.             jack_nframes_t sample_rate = 48000;

  533.             int audio_capture_ports = 2;

  534.             int audio_playback_ports = 2;

  535.             int midi_input_ports = 0;

  536.             int midi_output_ports = 0;

  537.             bool monitor = false;

  538.             char network_mode = 'n';

  539. 

  540.             const JSList* node;

  541.             const jack_driver_param_t* param;

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

  543.             {

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

  545.                 switch ( param->character )

  546.                 {

  547.                 case 'a' :

  548.                     multicast_ip = strdup ( param->value.str );

  549.                     break;

  550.                 case 'p':

  551.                     udp_port = param->value.ui;

  552.                     break;

  553.                 case 'M':

  554.                     mtu = param->value.i;

  555.                     break;

  556.                 case 'C':

  557.                     audio_capture_ports = param->value.i;

  558.                     break;

  559.                 case 'P':

  560.                     audio_playback_ports = param->value.i;

  561.                     break;

  562.                 case 'i':

  563.                     midi_input_ports = param->value.i;

  564.                     break;

  565.                 case 'o':

  566.                     midi_output_ports = param->value.i;

  567.                     break;

  568.                 case 'n' :

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

  570.                     break;

  571.                 case 't' :

  572.                     transport_sync = param->value.ui;

  573.                     break;

  574.                 case 'f' :

  575.                     network_mode = 'f';

  576.                     break;

  577.                 }

  578.             }

  579. 

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

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

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

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

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

  585.                 return driver;

  586. 

  587.             delete driver;

  588.             return NULL;

  589.         }

  590. 

  591. #ifdef __cplusplus

  592.     }

  593. #endif

  594. }