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

594 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.         fMulticastIP = new char[strlen ( ip ) + 1];

  44.         strcpy ( fMulticastIP, ip );

  45.         fParams.fMtu = mtu;

  46.         fParams.fSendMidiChannels = midi_input_ports;

  47.         fParams.fReturnMidiChannels = midi_output_ports;

  48.         strcpy ( fParams.fName, net_name );

  49.         fSocket.GetName ( fParams.fSlaveNetName );

  50.         fParams.fTransportSync = transport_sync;

  51.         fParams.fNetworkMode = network_mode;

  52. #ifdef JACK_MONITOR

  53.         fNetTimeMon = NULL;

  54.         fCycleTimeMon = NULL;

  55. #endif

  56.     }

  57. 

  58.     JackNetDriver::~JackNetDriver()

  59.     {

  60.         fSocket.Close();

  61.         delete[] fMidiCapturePortList;

  62.         delete[] fMidiPlaybackPortList;

  63. #ifdef JACK_MONITOR

  64.         delete fNetTimeMon;

  65.         delete fCycleTimeMon;

  66. #endif

  67.     }

  68. 

  69. //*************************************initialization***********************************************************************

  70. 

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

  72.                               int inchannels, int outchannels, bool monitor,

  73.                               const char* capture_driver_name, const char* playback_driver_name,

  74.                               jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  75.     {

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

  77.                                           capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  78.         fEngineControl->fPeriod = 0;

  79.         fEngineControl->fComputation = 500 * 1000;

  80.         fEngineControl->fConstraint = 500 * 1000;

  81.         return res;

  82.     }

  83. 

  84. #ifdef JACK_MONITOR

  85.     int JackNetDriver::Close()

  86.     {

  87.         if ( fNetTimeMon )

  88.             fNetTimeMon->Save();

  89.         if ( fCycleTimeMon )

  90.             fCycleTimeMon->Save();

  91.         return JackDriver::Close();

  92.     }

  93. #endif

  94. 

  95.     int JackNetDriver::Attach()

  96.     {

  97.         return 0;

  98.     }

  99. 

  100.     int JackNetDriver::Detach()

  101.     {

  102.         return 0;

  103.     }

  104. 

  105.     bool JackNetDriver::Init()

  106.     {

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

  108. 

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

  110.         if ( fSocket.IsSocket() )

  111.             Restart();

  112. 

  113.         //set the parameters to send

  114.         fParams.fSendAudioChannels = fCaptureChannels;

  115.         fParams.fReturnAudioChannels = fPlaybackChannels;

  116.         fParams.fSlaveSyncMode = fEngineControl->fSyncMode;

  117. 

  118. 		//display some additional infos

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

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

  121. 

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

  123.             return false;;

  124. 

  125.         //driver parametering

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

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

  128. 

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

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

  131. 

  132.         //allocate midi ports lists

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

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

  135. 

  136. 		//register jack ports

  137.         if ( AllocPorts() != 0 )

  138.         {

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

  140.             return false;

  141.         }

  142. 

  143.         //set global paramaters

  144.         SetParams();

  145. 

  146.         //init done, display parameters

  147.         SessionParamsDisplay ( &fParams );

  148. 

  149.         //monitor

  150. #ifdef JACK_MONITOR

  151.         string plot_name;

  152.         //NetTimeMon

  153.         plot_name = string ( fParams.fName );

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

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

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

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

  158.         string net_time_mon_fields[] =

  159.         {

  160.             string ( "end of read" ),

  161.             string ( "start of write" ),

  162.             string ( "sync send" ),

  163.             string ( "end of write" )

  164.         };

  165.         string net_time_mon_options[] =

  166.         {

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

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

  169.         };

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

  171.         //CycleTimeMon

  172.         plot_name.clear();

  173.         plot_name = string ( fParams.fName );

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

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

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

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

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

  179.         string cycle_time_mon_options[] =

  180.         {

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

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

  183.         };

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

  185.         fLastCycleBeginDate = GetMicroSeconds();

  186. #endif

  187. 

  188.         return true;

  189.     }

  190. 

  191.     void JackNetDriver::Restart()

  192.     {

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

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

  195.         delete[] fTxBuffer;

  196.         fTxBuffer = NULL;

  197.         delete[] fRxBuffer;

  198.         fRxBuffer = NULL;

  199.         delete fNetAudioCaptureBuffer;

  200.         fNetAudioCaptureBuffer = NULL;

  201.         delete fNetAudioPlaybackBuffer;

  202.         fNetAudioPlaybackBuffer = NULL;

  203.         delete fNetMidiCaptureBuffer;

  204.         fNetMidiCaptureBuffer = NULL;

  205.         delete fNetMidiPlaybackBuffer;

  206.         fNetMidiPlaybackBuffer = NULL;

  207.         FreePorts();

  208.         delete[] fMidiCapturePortList;

  209.         fMidiCapturePortList = NULL;

  210.         delete[] fMidiPlaybackPortList;

  211.         fMidiPlaybackPortList = NULL;

  212. #ifdef JACK_MONITOR

  213.         delete fNetTimeMon;

  214.         fNetTimeMon = NULL;

  215.         delete fCycleTimeMon;

  216.         fCycleTimeMon = NULL;

  217. #endif

  218.     }

  219. 

  220.     int JackNetDriver::AllocPorts()

  221.     {

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

  223.         JackPort* port;

  224.         jack_port_id_t port_id;

  225.         char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  226.         char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  227.         unsigned long port_flags;

  228.         int audio_port_index;

  229.         uint midi_port_index;

  230. 

  231.         //audio

  232.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  234.         {

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

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

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

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

  239.             {

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

  241.                 return -1;

  242.             }

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

  244.             port->SetAlias ( alias );

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

  246.             fCapturePortList[audio_port_index] = port_id;

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

  248.         }

  249.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  251.         {

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

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

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

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

  256.             {

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

  258.                 return -1;

  259.             }

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

  261.             port->SetAlias ( alias );

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

  263.             fPlaybackPortList[audio_port_index] = port_id;

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

  265.         }

  266.         //midi

  267.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  269.         {

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

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

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

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

  274.             {

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

  276.                 return -1;

  277.             }

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

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

  280.             fMidiCapturePortList[midi_port_index] = port_id;

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

  282.         }

  283. 

  284.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  286.         {

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

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

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

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

  291.             {

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

  293.                 return -1;

  294.             }

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

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

  297.             fMidiPlaybackPortList[midi_port_index] = port_id;

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

  299.         }

  300. 

  301.         return 0;

  302.     }

  303. 

  304.     int JackNetDriver::FreePorts()

  305.     {

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

  307.         int audio_port_index;

  308.         uint midi_port_index;

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

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

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

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

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

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

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

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

  317.         return 0;

  318.     }

  319. 

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

  321.     {

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

  323.     }

  324. 

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

  326.     {

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

  328.     }

  329. 

  330.     int JackNetDriver::SetSyncPacket()

  331.     {

  332.         if ( fParams.fTransportSync )

  333.         {

  334.             //set the TransportData

  335. 

  336.             //copy to TxBuffer

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

  338.         }

  339.         return 0;

  340.     }

  341. 

  342. //*************************************process************************************************************************

  343. 

  344.     int JackNetDriver::Read()

  345.     {

  346.         uint midi_port_index;

  347.         int audio_port_index;

  348. 

  349.         //buffers

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

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

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

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

  354. 

  355. #ifdef JACK_MONITOR

  356.         fNetTimeMon->New();

  357. #endif

  358. 

  359.         //receive sync (launch the cycle)

  360.         if ( SyncRecv() == SOCKET_ERROR )

  361.             return 0;

  362. 

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

  364.         JackDriver::CycleTakeBeginTime();

  365. 

  366. #ifdef JACK_MONITOR

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

  368.         fCycleTimeMon->Write();

  369.         fLastCycleBeginDate = JackDriver::fBeginDateUst;

  370. #endif

  371. 

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

  373.         if ( DataRecv() == SOCKET_ERROR )

  374.             return SOCKET_ERROR;

  375. 

  376. #ifdef JACK_MONITOR

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

  378. #endif

  379. 

  380.         return 0;

  381.     }

  382. 

  383.     int JackNetDriver::Write()

  384.     {

  385.         uint midi_port_index;

  386.         int audio_port_index;

  387. 

  388.         //buffers

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

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

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

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

  393. 

  394. #ifdef JACK_MONITOR

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

  396. #endif

  397. 

  398.         //sync

  399.         memset ( fTxData, 0, fPayloadSize );

  400.         SetSyncPacket();

  401. 

  402. 		//send sync

  403.         if ( SyncSend() == SOCKET_ERROR )

  404.             return SOCKET_ERROR;

  405. 

  406. #ifdef JACK_MONITOR

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

  408. #endif

  409. 

  410. 		//send data

  411.         if ( DataSend() == SOCKET_ERROR )

  412.             return SOCKET_ERROR;

  413. 

  414. #ifdef JACK_MONITOR

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

  416. #endif

  417. 

  418.         return 0;

  419.     }

  420. 

  421. //*************************************loader*******************************************************

  422. 

  423. #ifdef __cplusplus

  424.     extern "C"

  425.     {

  426. #endif

  427.         EXPORT jack_driver_desc_t* driver_get_descriptor ()

  428.         {

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

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

  431.             desc->nparams = 10;

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

  433. 

  434.             int i = 0;

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

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

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

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

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

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

  441. 

  442.             i++;

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

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

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

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

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

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

  449. 

  450.             i++;

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

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

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

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

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

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

  457. 

  458.             i++;

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

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

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

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

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

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

  465. 

  466.             i++;

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

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

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

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

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

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

  473. 

  474.             i++;

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

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

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

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

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

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

  481. 

  482.             i++;

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

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

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

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

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

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

  489. 

  490.             i++;

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

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

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

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

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

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

  497. 

  498.             i++;

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

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

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

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

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

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

  505. 

  506.             i++;

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

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

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

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

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

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

  513. 

  514.             return desc;

  515.         }

  516. 

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

  518.         {

  519.             if ( SocketAPIInit() < 0 )

  520.             {

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

  522.                 return NULL;

  523.             }

  524.             const char* multicast_ip = DEFAULT_MULTICAST_IP;

  525.             char name[JACK_CLIENT_NAME_SIZE];

  526.             GetHostName ( name, JACK_CLIENT_NAME_SIZE );

  527.             int udp_port = DEFAULT_PORT;

  528.             int mtu = 1500;

  529.             uint transport_sync = 1;

  530.             jack_nframes_t period_size = 128;

  531.             jack_nframes_t sample_rate = 48000;

  532.             int audio_capture_ports = 2;

  533.             int audio_playback_ports = 2;

  534.             int midi_input_ports = 0;

  535.             int midi_output_ports = 0;

  536.             bool monitor = false;

  537.             char network_mode = 'n';

  538. 

  539.             const JSList* node;

  540.             const jack_driver_param_t* param;

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

  542.             {

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

  544.                 switch ( param->character )

  545.                 {

  546.                 case 'a' :

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

  548.                     break;

  549.                 case 'p':

  550.                     udp_port = param->value.ui;

  551.                     break;

  552.                 case 'M':

  553.                     mtu = param->value.i;

  554.                     break;

  555.                 case 'C':

  556.                     audio_capture_ports = param->value.i;

  557.                     break;

  558.                 case 'P':

  559.                     audio_playback_ports = param->value.i;

  560.                     break;

  561.                 case 'i':

  562.                     midi_input_ports = param->value.i;

  563.                     break;

  564.                 case 'o':

  565.                     midi_output_ports = param->value.i;

  566.                     break;

  567.                 case 'n' :

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

  569.                     break;

  570.                 case 't' :

  571.                     transport_sync = param->value.ui;

  572.                     break;

  573.                 case 'f' :

  574.                     network_mode = 'f';

  575.                     break;

  576.                 }

  577.             }

  578. 

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

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

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

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

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

  584.                 return driver;

  585. 

  586.             delete driver;

  587.             return NULL;

  588.         }

  589. 

  590. #ifdef __cplusplus

  591.     }

  592. #endif

  593. }