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

761 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 "JackGraphManager.h"

  23. #include "JackWaitThreadedDriver.h"

  24. 

  25. 

  26. using namespace std;

  27. 

  28. namespace Jack

  29. {

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

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

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

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

  34.     {

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

  36. 

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

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

  39.             GetHostName ( net_name, JACK_CLIENT_NAME_SIZE );

  40. 

  41.         fParams.fMtu = mtu;

  42.         fParams.fSendMidiChannels = midi_input_ports;

  43.         fParams.fReturnMidiChannels = midi_output_ports;

  44.         strcpy ( fParams.fName, net_name );

  45.         fSocket.GetName ( fParams.fSlaveNetName );

  46.         fParams.fTransportSync = transport_sync;

  47.         fParams.fNetworkMode = network_mode;

  48.         fLastTimebaseMaster = -1;

  49.         fMidiCapturePortList = NULL;

  50.         fMidiPlaybackPortList = NULL;

  51. #ifdef JACK_MONITOR

  52.         fNetTimeMon = NULL;

  53. #endif

  54.     }

  55. 

  56.     JackNetDriver::~JackNetDriver()

  57.     {

  58.         delete[] fMidiCapturePortList;

  59.         delete[] fMidiPlaybackPortList;

  60. #ifdef JACK_MONITOR

  61.         delete fNetTimeMon;

  62. #endif

  63.     }

  64. 

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

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

  67.                               int inchannels, int outchannels, bool monitor,

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

  69.                               jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  70.     {

  71.         if ( JackAudioDriver::Open ( buffer_size,

  72.                                      samplerate,

  73.                                      capturing,

  74.                                      playing,

  75.                                      inchannels,

  76.                                      outchannels,

  77.                                      monitor,

  78.                                      capture_driver_name,

  79.                                      playback_driver_name,

  80.                                      capture_latency,

  81.                                      playback_latency ) == 0 )

  82.         {

  83.             fEngineControl->fPeriod = 0;

  84.             fEngineControl->fComputation = 500 * 1000;

  85.             fEngineControl->fConstraint = 500 * 1000;

  86.             return 0;

  87.         }

  88.         else

  89.         {

  90.             return -1;

  91.         }

  92.     }

  93. 

  94. #ifdef JACK_MONITOR

  95.     int JackNetDriver::Close()

  96.     {

  97.         if ( fNetTimeMon )

  98.             fNetTimeMon->Save();

  99.         return JackDriver::Close();

  100.     }

  101. #endif

  102. 

  103.     // Attach and Detach are defined as empty methods: port allocation is done when driver actually start (that is in Init)

  104.     int JackNetDriver::Attach()

  105.     {

  106.         return 0;

  107.     }

  108. 

  109.     int JackNetDriver::Detach()

  110.     {

  111.         return 0;

  112.     }

  113. 

  114. //init and restart--------------------------------------------------------------------

  115.     bool JackNetDriver::Init()

  116.     {

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

  118. 

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

  120.         if ( fSocket.IsSocket() )

  121.             Restart();

  122. 

  123.         //set the parameters to send

  124.         fParams.fSendAudioChannels = fCaptureChannels;

  125.         fParams.fReturnAudioChannels = fPlaybackChannels;

  126.         fParams.fSlaveSyncMode = fEngineControl->fSyncMode;

  127. 

  128.         //display some additional infos

  129.         jack_info ( "NetDriver started in %s mode %s Master's transport sync.",

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

  131. 

  132.         //init network

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

  134.             return false;

  135. 

  136.         //set global parameters

  137.         SetParams();

  138.          

  139.         //allocate midi ports lists

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

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

  142.         assert ( fMidiCapturePortList );

  143.         assert ( fMidiPlaybackPortList );

  144. 

  145.         //register jack ports

  146.         if ( AllocPorts() != 0 )

  147.         {

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

  149.             return false;

  150.         }

  151. 

  152.         //init done, display parameters

  153.         SessionParamsDisplay ( &fParams );

  154. 

  155.         //monitor

  156. #ifdef JACK_MONITOR

  157.         string plot_name;

  158.         //NetTimeMon

  159.         plot_name = string ( fParams.fName );

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

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

  162.         switch ( fParams.fNetworkMode )

  163.         {

  164.             case 's' :

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

  166.                 break;

  167. 

  168.             case 'n' :

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

  170.                 break;

  171. 

  172.             case 'f' :

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

  174.                 break;

  175.         }

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

  177.         string net_time_mon_fields[] =

  178.         {

  179.             string ( "sync decoded" ),

  180.             string ( "end of read" ),

  181.             string ( "start of write" ),

  182.             string ( "sync send" ),

  183.             string ( "end of write" )

  184.         };

  185.         string net_time_mon_options[] =

  186.         {

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

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

  189.         };

  190.         fNetTimeMon->SetPlotFile ( net_time_mon_options, 2, net_time_mon_fields, 5 );

  191. #endif

  192.         //driver parametering

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

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

  195. 

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

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

  198. 

  199.         //transport engine parametering

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

  201.         return true;

  202.     }

  203. 

  204.     void JackNetDriver::Restart()

  205.     {

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

  207. 

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

  209.         delete[] fTxBuffer;

  210.         fTxBuffer = NULL;

  211.         delete[] fRxBuffer;

  212.         fRxBuffer = NULL;

  213.         delete fNetAudioCaptureBuffer;

  214.         fNetAudioCaptureBuffer = NULL;

  215.         delete fNetAudioPlaybackBuffer;

  216.         fNetAudioPlaybackBuffer = NULL;

  217.         delete fNetMidiCaptureBuffer;

  218.         fNetMidiCaptureBuffer = NULL;

  219.         delete fNetMidiPlaybackBuffer;

  220.         fNetMidiPlaybackBuffer = NULL;

  221.         FreePorts();

  222.         delete[] fMidiCapturePortList;

  223.         fMidiCapturePortList = NULL;

  224.         delete[] fMidiPlaybackPortList;

  225.         fMidiPlaybackPortList = NULL;

  226. #ifdef JACK_MONITOR

  227.         delete fNetTimeMon;

  228.         fNetTimeMon = NULL;

  229. #endif

  230.     }

  231. 

  232. //jack ports and buffers--------------------------------------------------------------

  233.     int JackNetDriver::AllocPorts()

  234.     {

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

  236. 

  237.         JackPort* port;

  238.         jack_port_id_t port_id;

  239.         char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  240.         char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  241.         unsigned long port_flags;

  242.         int audio_port_index;

  243.         uint midi_port_index;

  244. 

  245.         //audio

  246.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  248.         {

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

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

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

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

  253.             {

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

  255.                 return -1;

  256.             }

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

  258.             port->SetAlias ( alias );

  259.             //port latency

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

  261.             fCapturePortList[audio_port_index] = port_id;

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

  263.         }

  264.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  266.         {

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

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

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

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

  271.             {

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

  273.                 return -1;

  274.             }

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

  276.             port->SetAlias ( alias );

  277.             //port latency

  278.             switch ( fParams.fNetworkMode )

  279.             {

  280.                 case 'f' :

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

  282.                     break;

  283.                 case 'n' :

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

  285.                     break;

  286.                 case 's' :

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

  288.                     break;

  289.             }

  290.             fPlaybackPortList[audio_port_index] = port_id;

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

  292.         }

  293.         //midi

  294.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  296.         {

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

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

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

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

  301.             {

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

  303.                 return -1;

  304.             }

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

  306.             //port latency

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

  308.             fMidiCapturePortList[midi_port_index] = port_id;

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

  310.         }

  311. 

  312.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  314.         {

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

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

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

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

  319.             {

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

  321.                 return -1;

  322.             }

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

  324.             //port latency

  325.             switch ( fParams.fNetworkMode )

  326.             {

  327.                 case 'f' :

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

  329.                     break;

  330.                 case 'n' :

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

  332.                     break;

  333.                 case 's' :

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

  335.                     break;

  336.             }

  337.             fMidiPlaybackPortList[midi_port_index] = port_id;

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

  339.         }

  340. 

  341.         return 0;

  342.     }

  343. 

  344.     int JackNetDriver::FreePorts()

  345.     {

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

  347. 

  348.         int audio_port_index;

  349.         uint midi_port_index;

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

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

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

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

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

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

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

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

  358.         return 0;

  359.     }

  360. 

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

  362.     {

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

  364.     }

  365. 

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

  367.     {

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

  369.     }

  370. 

  371. //transport---------------------------------------------------------------------------

  372.     int JackNetDriver::DecodeTransportData()

  373.     {

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

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

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

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

  378.         int refnum;

  379.         bool conditional;

  380.         if ( fSendTransportData.fTimebaseMaster == TIMEBASEMASTER )

  381.         {

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

  383.             if ( refnum != -1 )

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

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

  386.         }

  387. 

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

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

  390.         {

  391.             switch ( fSendTransportData.fState )

  392.             {

  393.                 case JackTransportStopped :

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

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

  396.                     break;

  397. 

  398.                 case JackTransportStarting :

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

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

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

  402.                     break;

  403. 

  404.                 case JackTransportRolling :

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

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

  407.                     break;

  408.             }

  409.         }

  410. 

  411.         return 0;

  412.     }

  413. 

  414.     int JackNetDriver::EncodeTransportData()

  415.     {

  416.         //is there a timebase master change ?

  417.         int refnum;

  418.         bool conditional;

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

  420.         if ( refnum != fLastTimebaseMaster )

  421.         {

  422.             //timebase master has released its function

  423.             if ( refnum == -1 )

  424.             {

  425.                 fReturnTransportData.fTimebaseMaster = RELEASE_TIMEBASEMASTER;

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

  427.             }

  428.             //there is a new timebase master

  429.             else

  430.             {

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

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

  433.             }

  434.             fLastTimebaseMaster = refnum;

  435.         }

  436.         else

  437.             fReturnTransportData.fTimebaseMaster = NO_CHANGE;

  438. 

  439.         //update transport state and position

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

  441. 

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

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

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

  445.         if ( fReturnTransportData.fNewState )

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

  447.         fLastTransportState = fReturnTransportData.fState;

  448. 

  449.         return 0;

  450.     }

  451. 

  452. //network sync------------------------------------------------------------------------

  453.     int JackNetDriver::DecodeSyncPacket()

  454.     {

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

  456.         //first : transport

  457.         if ( fParams.fTransportSync )

  458.         {

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

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

  461.             if ( DecodeTransportData() < 0 )

  462.                 return -1;

  463.         }

  464.         //then others

  465.         //...

  466.         return 0;

  467.     }

  468. 

  469.     int JackNetDriver::EncodeSyncPacket()

  470.     {

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

  472.         //first of all, reset sync packet

  473.         memset ( fTxData, 0, fPayloadSize );

  474.         //then first step : transport

  475.         if ( fParams.fTransportSync )

  476.         {

  477.             if ( EncodeTransportData() < 0 )

  478.                 return -1;

  479.             //copy to TxBuffer

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

  481.         }

  482.         //then others

  483.         //...

  484.         return 0;

  485.     }

  486. 

  487. //driver processes--------------------------------------------------------------------

  488.     int JackNetDriver::Read()

  489.     {

  490.         uint midi_port_index;

  491.         uint audio_port_index;

  492. 

  493.         //buffers

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

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

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

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

  498. 

  499. #ifdef JACK_MONITOR

  500.         fNetTimeMon->New();

  501. #endif

  502. 

  503.         //receive sync (launch the cycle)

  504.         if ( SyncRecv() == SOCKET_ERROR )

  505.             return 0;

  506. 

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

  508.         JackDriver::CycleTakeBeginTime();

  509. 

  510.         //decode sync

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

  512.         if ( DecodeSyncPacket() < 0 )

  513.             return 0;

  514. 

  515. #ifdef JACK_MONITOR

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

  517. #endif

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

  519.         if ( DataRecv() == SOCKET_ERROR )

  520.             return SOCKET_ERROR;

  521. 

  522. #ifdef JACK_MONITOR

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

  524. #endif

  525. 

  526.         return 0;

  527.     }

  528. 

  529.     int JackNetDriver::Write()

  530.     {

  531.         uint midi_port_index;

  532.         int audio_port_index;

  533. 

  534.         //buffers

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

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

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

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

  539. 

  540. #ifdef JACK_MONITOR

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

  542. #endif

  543. 

  544.         //sync

  545.         if ( EncodeSyncPacket() < 0 )

  546.             return 0;

  547. 

  548.         //send sync

  549.         if ( SyncSend() == SOCKET_ERROR )

  550.             return SOCKET_ERROR;

  551. 

  552. #ifdef JACK_MONITOR

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

  554. #endif

  555. 

  556.         //send data

  557.         if ( DataSend() == SOCKET_ERROR )

  558.             return SOCKET_ERROR;

  559. 

  560. #ifdef JACK_MONITOR

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

  562. #endif

  563. 

  564.         return 0;

  565.     }

  566. 

  567. //driver loader-----------------------------------------------------------------------

  568. 

  569. #ifdef __cplusplus

  570.     extern "C"

  571.     {

  572. #endif

  573.         SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor ()

  574.         {

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

  576. 

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

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

  579. 

  580.             desc->nparams = 10;

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

  582. 

  583.             int i = 0;

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

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

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

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

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

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

  590. 

  591.             i++;

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

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

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

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

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

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

  598. 

  599.             i++;

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

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

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

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

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

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

  606. 

  607.             i++;

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

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

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

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

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

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

  614. 

  615.             i++;

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

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

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

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

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

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

  622. 

  623.             i++;

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

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

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

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

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

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

  630. 

  631.             i++;

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

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

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

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

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

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

  638. 

  639.             i++;

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

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

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

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

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

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

  646. 

  647.             i++;

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

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

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

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

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

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

  654. 

  655.             i++;

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

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

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

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

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

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

  662. 

  663.             return desc;

  664.         }

  665. 

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

  667.         {

  668.             char multicast_ip[16];

  669.             strcpy ( multicast_ip, DEFAULT_MULTICAST_IP );

  670.             char net_name[JACK_CLIENT_NAME_SIZE];

  671.             int udp_port = DEFAULT_PORT;

  672.             int mtu = 1500;

  673.             uint transport_sync = 1;

  674.             jack_nframes_t period_size = 128;

  675.             jack_nframes_t sample_rate = 48000;

  676.             int audio_capture_ports = 2;

  677.             int audio_playback_ports = 2;

  678.             int midi_input_ports = 0;

  679.             int midi_output_ports = 0;

  680.             bool monitor = false;

  681.             char network_mode = 's';

  682.             const JSList* node;

  683.             const jack_driver_param_t* param;

  684. 

  685.             net_name[0] = 0;

  686. 

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

  688.             {

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

  690.                 switch ( param->character )

  691.                 {

  692.                     case 'a' :

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

  694.                         break;

  695.                     case 'p':

  696.                         udp_port = param->value.ui;

  697.                         break;

  698.                     case 'M':

  699.                         mtu = param->value.i;

  700.                         break;

  701.                     case 'C':

  702.                         audio_capture_ports = param->value.i;

  703.                         break;

  704.                     case 'P':

  705.                         audio_playback_ports = param->value.i;

  706.                         break;

  707.                     case 'i':

  708.                         midi_input_ports = param->value.i;

  709.                         break;

  710.                     case 'o':

  711.                         midi_output_ports = param->value.i;

  712.                         break;

  713.                     case 'n' :

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

  715.                         break;

  716.                     case 't' :

  717.                         transport_sync = param->value.ui;

  718.                         break;

  719.                     case 'm' :

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

  721.                             network_mode = 'n';

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

  723.                             network_mode = 's';

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

  725.                             network_mode = 'f';

  726.                         else

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

  728.                         break;

  729.                 }

  730.             }

  731. 

  732.             try

  733.             {

  734. 

  735.                 Jack::JackDriverClientInterface* driver =

  736.                     new Jack::JackWaitThreadedDriver (

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

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

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

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

  741.                 {

  742.                     return driver;

  743.                 }

  744.                 else

  745.                 {

  746.                     delete driver;

  747.                     return NULL;

  748.                 }

  749. 

  750.             }

  751.             catch ( ... )

  752.             {

  753.                 return NULL;

  754.             }

  755.         }

  756. 

  757. #ifdef __cplusplus

  758.     }

  759. #endif

  760. }