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

742 lines
31KB
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. #include "JackNetDriver.h"

  21. #include "JackEngineControl.h"

  22. #include "JackClientControl.h"

  23. #include "JackGraphManager.h"

  24. #include "JackDriverLoader.h"

  25. #include "JackThreadedDriver.h"

  26. #include "JackWaitThreadedDriver.h"

  27. 

  28. using namespace std;

  29. 

  30. namespace Jack

  31. {

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

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

  34.                                    char* net_name, uint transport_sync, char network_mode )

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

  36.     {

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

  38.         

  39.         // Use the hostname if no name parameter was given

  40.         if (strcmp(net_name, "") == 0)

  41.            GetHostName(net_name, JACK_CLIENT_NAME_SIZE);

  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.         fLastTimebaseMaster = -1;

  51.         fMidiCapturePortList = NULL;

  52.         fMidiPlaybackPortList = NULL;

  53. #ifdef JACK_MONITOR

  54.         fNetTimeMon = NULL;

  55. #endif

  56.     }

  57. 

  58.     JackNetDriver::~JackNetDriver()

  59.     {

  60.         delete[] fMidiCapturePortList;

  61.         delete[] fMidiPlaybackPortList;

  62. #ifdef JACK_MONITOR

  63.         delete fNetTimeMon;

  64. #endif

  65.     }

  66. 

  67. //open, close, attach and detach------------------------------------------------------

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

  69.                               int inchannels, int outchannels, bool monitor,

  70.                               const char* capture_driver_name, const char* playback_driver_name,

  71.                               jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  72.     {

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

  74.                                           capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  75.         fEngineControl->fPeriod = 0;

  76.         fEngineControl->fComputation = 500 * 1000;

  77.         fEngineControl->fConstraint = 500 * 1000;

  78.         return res;

  79.     }

  80. 

  81. #ifdef JACK_MONITOR

  82.     int JackNetDriver::Close()

  83.     {

  84.         if ( fNetTimeMon )

  85.             fNetTimeMon->Save();

  86.         return JackDriver::Close();

  87.     }

  88. #endif

  89. 

  90.     int JackNetDriver::Attach()

  91.     {

  92.         return 0;

  93.     }

  94. 

  95.     int JackNetDriver::Detach()

  96.     {

  97.         return 0;

  98.     }

  99. 

  100. //init and restart--------------------------------------------------------------------

  101.     bool JackNetDriver::Init()

  102.     {

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

  104. 

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

  106.         if ( fSocket.IsSocket() )

  107.             Restart();

  108. 

  109.         //set the parameters to send

  110.         fParams.fSendAudioChannels = fCaptureChannels;

  111.         fParams.fReturnAudioChannels = fPlaybackChannels;

  112.         fParams.fSlaveSyncMode = fEngineControl->fSyncMode;

  113. 

  114.         //display some additional infos

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

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

  117. 

  118.         //init network

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

  120.             return false;

  121. 

  122.         //set global paramaters

  123.         SetParams();

  124. 

  125.         //register jack ports

  126.         if ( AllocPorts() != 0 )

  127.         {

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

  129.             return false;

  130.         }

  131. 

  132.         //init done, display parameters

  133.         SessionParamsDisplay ( &fParams );

  134. 

  135.         //monitor

  136. #ifdef JACK_MONITOR

  137.         string plot_name;

  138.         //NetTimeMon

  139.         plot_name = string ( fParams.fName );

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

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

  142.         switch ( fParams.fNetworkMode )

  143.         {

  144.             case 's' :

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

  146.                 break;

  147.                 

  148.             case 'n' :

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

  150.                 break;

  151.                 

  152.             case 'f' :

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

  154.                 break;

  155.         }

  156.         fNetTimeMon = new JackGnuPlotMonitor<float> ( 128, 5, plot_name );

  157.         string net_time_mon_fields[] =

  158.         {

  159.             string ( "sync decoded" ),

  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, 5 );

  171. #endif

  172.         //driver parametering

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

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

  175. 

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

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

  178. 

  179.         //transport engine parametering

  180.         fEngineControl->fTransport.SetNetworkSync ( true );

  181. 

  182.         //allocate midi ports lists

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

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

  185.         assert(fMidiCapturePortList);

  186.         assert(fMidiPlaybackPortList);

  187. 

  188.         return true;

  189.     }

  190. 

  191.     void JackNetDriver::Restart()

  192.     {

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

  194. 

  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. #endif

  217.     }

  218. 

  219. //jack ports and buffers--------------------------------------------------------------

  220.     int JackNetDriver::AllocPorts()

  221.     {

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

  223. 

  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 latency

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

  248.             fCapturePortList[audio_port_index] = port_id;

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

  250.         }

  251.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  253.         {

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

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

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

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

  258.             {

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

  260.                 return -1;

  261.             }

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

  263.             port->SetAlias ( alias );

  264.             //port latency

  265.             switch ( fParams.fNetworkMode )

  266.             {

  267.                 case 'f' :

  268.                     port->SetLatency ( ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize );

  269.                     break;

  270.                 case 'n' :

  271.                     port->SetLatency ( fEngineControl->fBufferSize + ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize );

  272.                     break;

  273.                 case 's' :

  274.                     port->SetLatency ( 2 * fEngineControl->fBufferSize + ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize );

  275.                     break;

  276.             }

  277.             fPlaybackPortList[audio_port_index] = port_id;

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

  279.         }

  280.         //midi

  281.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  283.         {

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

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

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

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

  288.             {

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

  290.                 return -1;

  291.             }

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

  293.             //port latency

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

  295.             fMidiCapturePortList[midi_port_index] = port_id;

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

  297.         }

  298. 

  299.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  301.         {

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

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

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

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

  306.             {

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

  308.                 return -1;

  309.             }

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

  311.             //port latency

  312.             switch ( fParams.fNetworkMode )

  313.             {

  314.                 case 'f' :

  315.                     port->SetLatency ( ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize );

  316.                     break;

  317.                 case 'n' :

  318.                     port->SetLatency ( fEngineControl->fBufferSize + ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize ) ;

  319.                     break;

  320.                 case 's' :

  321.                     port->SetLatency ( 2 * fEngineControl->fBufferSize + ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize );

  322.                     break;

  323.             }

  324.             fMidiPlaybackPortList[midi_port_index] = port_id;

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

  326.         }

  327. 

  328.         return 0;

  329.     }

  330. 

  331.     int JackNetDriver::FreePorts()

  332.     {

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

  334. 

  335.         int audio_port_index;

  336.         uint midi_port_index;

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

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

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

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

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

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

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

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

  345.         return 0;

  346.     }

  347. 

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

  349.     {

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

  351.     }

  352. 

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

  354.     {

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

  356.     }

  357. 

  358. //transport---------------------------------------------------------------------------

  359.     int JackNetDriver::DecodeTransportData()

  360.     {

  361.         //is there a new timebase master on the net master ?

  362.         // - release timebase master only if it's a non-conditional request

  363.         // - no change or no request : don't do anything

  364.         // - conditional request : don't change anything too, the master will know if this slave is actually the timebase master

  365.         int refnum;

  366.         bool conditional;

  367.         if ( fSendTransportData.fTimebaseMaster == TIMEBASEMASTER )

  368.         {

  369.             fEngineControl->fTransport.GetTimebaseMaster ( refnum, conditional );

  370.             if ( refnum != -1 )

  371.                 fEngineControl->fTransport.ResetTimebase ( refnum );

  372.             jack_info ( "The NetMaster is now the new timebase master." );

  373.         }

  374. 

  375.         //is there a tranport state change to handle ?

  376.         if ( fSendTransportData.fNewState && ( fSendTransportData.fState != fEngineControl->fTransport.GetState() ) )

  377.         {

  378.             switch ( fSendTransportData.fState )

  379.             {

  380.                 case JackTransportStopped :

  381.                     fEngineControl->fTransport.SetCommand ( TransportCommandStop );

  382.                     jack_info ( "Master stops transport." );

  383.                     break;

  384.                     

  385.                 case JackTransportStarting :

  386.                     fEngineControl->fTransport.RequestNewPos ( &fSendTransportData.fPosition );

  387.                     fEngineControl->fTransport.SetCommand ( TransportCommandStart );

  388.                     jack_info ( "Master starts transport." );

  389.                     break;

  390.                     

  391.                 case JackTransportRolling :

  392.                     fEngineControl->fTransport.SetState ( JackTransportRolling );

  393.                     jack_info ( "Master is rolling." );

  394.                     break;

  395.             }

  396.         }

  397. 

  398.         return 0;

  399.     }

  400. 

  401.     int JackNetDriver::EncodeTransportData()

  402.     {

  403.         //is there a timebase master change ?

  404.         int refnum;

  405.         bool conditional;

  406.         fEngineControl->fTransport.GetTimebaseMaster ( refnum, conditional );

  407.         if ( refnum != fLastTimebaseMaster )

  408.         {

  409.             //timebase master has released its function

  410.             if ( refnum == -1 )

  411.             {

  412.                 fReturnTransportData.fTimebaseMaster = RELEASE_TIMEBASEMASTER;

  413.                 jack_info ( "Sending a timebase master release request." );

  414.             }

  415.             //there is a new timebase master

  416.             else

  417.             {

  418.                 fReturnTransportData.fTimebaseMaster = ( conditional ) ? CONDITIONAL_TIMEBASEMASTER : TIMEBASEMASTER;

  419.                 jack_info ( "Sending a %s timebase master request.", ( conditional ) ? "conditional" : "non-conditional" );

  420.             }

  421.             fLastTimebaseMaster = refnum;

  422.         }

  423.         else

  424.             fReturnTransportData.fTimebaseMaster = NO_CHANGE;

  425. 

  426.         //update transport state and position

  427.         fReturnTransportData.fState = fEngineControl->fTransport.Query ( &fReturnTransportData.fPosition );

  428. 

  429.         //is it a new state (that the master need to know...) ?

  430.         fReturnTransportData.fNewState = ( ( fReturnTransportData.fState != fLastTransportState ) &&

  431.                                            ( fReturnTransportData.fState != fSendTransportData.fState ) );

  432.         if ( fReturnTransportData.fNewState )

  433.             jack_info ( "Sending '%s'.", GetTransportState ( fReturnTransportData.fState ) );

  434.         fLastTransportState = fReturnTransportData.fState;

  435. 

  436.         return 0;

  437.     }

  438. 

  439. //network sync------------------------------------------------------------------------

  440.     int JackNetDriver::DecodeSyncPacket()

  441.     {

  442.         //this method contains every step of sync packet informations decoding process

  443.         //first : transport

  444.         if ( fParams.fTransportSync )

  445.         {

  446.             //copy received transport data to transport data structure

  447.             memcpy ( &fSendTransportData, fRxData, sizeof ( net_transport_data_t ) );

  448.             if ( DecodeTransportData() < 0 )

  449.                 return -1;

  450.         }

  451.         //then others

  452.         //...

  453.         return 0;

  454.     }

  455. 

  456.     int JackNetDriver::EncodeSyncPacket()

  457.     {

  458.         //this method contains every step of sync packet informations coding

  459.         //first of all, reset sync packet

  460.         memset ( fTxData, 0, fPayloadSize );

  461.         //then first step : transport

  462.         if ( fParams.fTransportSync )

  463.         {

  464.             if ( EncodeTransportData() < 0 )

  465.                 return -1;

  466.             //copy to TxBuffer

  467.             memcpy ( fTxData, &fReturnTransportData, sizeof ( net_transport_data_t ) );

  468.         }

  469.         //then others

  470.         //...

  471.         return 0;

  472.     }

  473. 

  474. //driver processes--------------------------------------------------------------------

  475.     int JackNetDriver::Read()

  476.     {

  477.         uint midi_port_index;

  478.         uint audio_port_index;

  479. 

  480.         //buffers

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

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

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

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

  485. 

  486. #ifdef JACK_MONITOR

  487.         fNetTimeMon->New();

  488. #endif

  489. 

  490.         //receive sync (launch the cycle)

  491.         if ( SyncRecv() == SOCKET_ERROR )

  492.             return 0;

  493. 

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

  495.         JackDriver::CycleTakeBeginTime();

  496. 

  497.         //decode sync

  498.         //if there is an error, don't return -1, it will skip Write() and the network error probably won't be identified

  499.         if ( DecodeSyncPacket() < 0 )

  500.             return 0;

  501. 

  502. #ifdef JACK_MONITOR

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

  504. #endif

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

  506.         if ( DataRecv() == SOCKET_ERROR )

  507.             return SOCKET_ERROR;

  508. 

  509. #ifdef JACK_MONITOR

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

  511. #endif

  512. 

  513.         return 0;

  514.     }

  515. 

  516.     int JackNetDriver::Write()

  517.     {

  518.         uint midi_port_index;

  519.         int audio_port_index;

  520. 

  521.         //buffers

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

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

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

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

  526. 

  527. #ifdef JACK_MONITOR

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

  529. #endif

  530. 

  531.         //sync

  532.         if ( EncodeSyncPacket() < 0 )

  533.             return 0;

  534. 

  535.         //send sync

  536.         if ( SyncSend() == SOCKET_ERROR )

  537.             return SOCKET_ERROR;

  538. 

  539. #ifdef JACK_MONITOR

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

  541. #endif

  542. 

  543.         //send data

  544.         if ( DataSend() == SOCKET_ERROR )

  545.             return SOCKET_ERROR;

  546. 

  547. #ifdef JACK_MONITOR

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

  549. #endif

  550. 

  551.         return 0;

  552.     }

  553. 

  554. //driver loader-----------------------------------------------------------------------

  555. 

  556. #ifdef __cplusplus

  557.     extern "C"

  558.     {

  559. #endif

  560.         SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor ()

  561.         {

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

  563.             

  564.             strcpy(desc->name, "net");                                // size MUST be less then JACK_DRIVER_NAME_MAX + 1

  565.             strcpy(desc->desc, "netjack slave backend component");    // size MUST be less then JACK_DRIVER_PARAM_DESC + 1

  566.             

  567.             desc->nparams = 10;

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

  569. 

  570.             int i = 0;

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

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

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

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

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

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

  577. 

  578.             i++;

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

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

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

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

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

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

  585. 

  586.             i++;

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

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

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

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

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

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

  593. 

  594.             i++;

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

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

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

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

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

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

  601. 

  602.             i++;

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

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

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

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

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

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

  609. 

  610.             i++;

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

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

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

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

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

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

  617. 

  618.             i++;

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

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

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

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

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

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

  625. 

  626.             i++;

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

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

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

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

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

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

  633. 

  634.             i++;

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

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

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

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

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

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

  641. 

  642.             i++;

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

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

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

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

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

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

  649. 

  650.             return desc;

  651.         }

  652. 

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

  654.         {

  655.             char multicast_ip[16];

  656.             strcpy ( multicast_ip, DEFAULT_MULTICAST_IP );

  657.             char net_name[JACK_CLIENT_NAME_SIZE];

  658.             int udp_port = DEFAULT_PORT;

  659.             int mtu = 1500;

  660.             uint transport_sync = 1;

  661.             jack_nframes_t period_size = 128;

  662.             jack_nframes_t sample_rate = 48000;

  663.             int audio_capture_ports = 2;

  664.             int audio_playback_ports = 2;

  665.             int midi_input_ports = 0;

  666.             int midi_output_ports = 0;

  667.             bool monitor = false;

  668.             char network_mode = 'n';

  669.             const JSList* node;

  670.             const jack_driver_param_t* param;

  671.             

  672.             net_name[0] = 0;

  673.             

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

  675.             {

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

  677.                 switch ( param->character )

  678.                 {

  679.                     case 'a' :

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

  681.                         break;

  682.                     case 'p':

  683.                         udp_port = param->value.ui;

  684.                         break;

  685.                     case 'M':

  686.                         mtu = param->value.i;

  687.                         break;

  688.                     case 'C':

  689.                         audio_capture_ports = param->value.i;

  690.                         break;

  691.                     case 'P':

  692.                         audio_playback_ports = param->value.i;

  693.                         break;

  694.                     case 'i':

  695.                         midi_input_ports = param->value.i;

  696.                         break;

  697.                     case 'o':

  698.                         midi_output_ports = param->value.i;

  699.                         break;

  700.                     case 'n' :

  701.                         strncpy ( net_name, param->value.str, JACK_CLIENT_NAME_SIZE );

  702.                         break;

  703.                     case 't' :

  704.                         transport_sync = param->value.ui;

  705.                         break;

  706.                     case 'm' :

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

  708.                             network_mode = 'n';

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

  710.                             network_mode = 's';

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

  712.                             network_mode = 'f';

  713.                         else

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

  715.                         break;

  716.                 }

  717.             }

  718. 

  719.             try {

  720.             

  721.                 Jack::JackDriverClientInterface* driver = 

  722.                     new Jack::JackWaitThreadedDriver(

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

  724.                                           midi_input_ports, midi_output_ports, net_name, transport_sync, network_mode));

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

  726.                                 monitor, "from_master_", "to_master_", 0, 0) == 0) {

  727.                     return driver;

  728.                 } else {

  729.                     delete driver;

  730.                     return NULL;

  731.                 }

  732.                 

  733.             } catch (...) {

  734.                 return NULL;

  735.             }   

  736.         }

  737. 

  738. #ifdef __cplusplus

  739.     }

  740. #endif

  741. }