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

739 lines
30KB
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. #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.         int res = JackAudioDriver::Open ( buffer_size, samplerate, capturing, playing, inchannels, outchannels, monitor,

  72.                                           capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  73.         fEngineControl->fPeriod = 0;

  74.         fEngineControl->fComputation = 500 * 1000;

  75.         fEngineControl->fConstraint = 500 * 1000;

  76.         return res;

  77.     }

  78. 

  79. #ifdef JACK_MONITOR

  80.     int JackNetDriver::Close()

  81.     {

  82.         if ( fNetTimeMon )

  83.             fNetTimeMon->Save();

  84.         return JackDriver::Close();

  85.     }

  86. #endif

  87. 

  88.     int JackNetDriver::Attach()

  89.     {

  90.         return 0;

  91.     }

  92. 

  93.     int JackNetDriver::Detach()

  94.     {

  95.         return 0;

  96.     }

  97. 

  98. //init and restart--------------------------------------------------------------------

  99.     bool JackNetDriver::Init()

  100.     {

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

  102. 

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

  104.         if ( fSocket.IsSocket() )

  105.             Restart();

  106. 

  107.         //set the parameters to send

  108.         fParams.fSendAudioChannels = fCaptureChannels;

  109.         fParams.fReturnAudioChannels = fPlaybackChannels;

  110.         fParams.fSlaveSyncMode = fEngineControl->fSyncMode;

  111. 

  112.         //display some additional infos

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

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

  115. 

  116.         //init network

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

  118.             return false;

  119. 

  120.         //set global paramaters

  121.         SetParams();

  122. 

  123.         //driver parametering

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

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

  126. 

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

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

  129. 

  130.         //transport engine parametering

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

  132. 

  133.         //allocate midi ports lists

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

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

  136. 

  137.         //register jack ports

  138.         if ( AllocPorts() != 0 )

  139.         {

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

  141.             return false;

  142.         }

  143. 

  144.         //init done, display parameters

  145.         SessionParamsDisplay ( &fParams );

  146. 

  147.         //monitor

  148. #ifdef JACK_MONITOR

  149.         string plot_name;

  150.         //NetTimeMon

  151.         plot_name = string ( fParams.fName );

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

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

  154.         switch ( fParams.fNetworkMode )

  155.         {

  156.             case 's' :

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

  158.                 break;

  159.                 

  160.             case 'n' :

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

  162.                 break;

  163.                 

  164.             case 'f' :

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

  166.                 break;

  167.         }

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

  169.         string net_time_mon_fields[] =

  170.         {

  171.             string ( "sync decoded" ),

  172.             string ( "end of read" ),

  173.             string ( "start of write" ),

  174.             string ( "sync send" ),

  175.             string ( "end of write" )

  176.         };

  177.         string net_time_mon_options[] =

  178.         {

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

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

  181.         };

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

  183. #endif

  184. 

  185.         return true;

  186.     }

  187. 

  188.     void JackNetDriver::Restart()

  189.     {

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

  191. 

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

  193.         delete[] fTxBuffer;

  194.         fTxBuffer = NULL;

  195.         delete[] fRxBuffer;

  196.         fRxBuffer = NULL;

  197.         delete fNetAudioCaptureBuffer;

  198.         fNetAudioCaptureBuffer = NULL;

  199.         delete fNetAudioPlaybackBuffer;

  200.         fNetAudioPlaybackBuffer = NULL;

  201.         delete fNetMidiCaptureBuffer;

  202.         fNetMidiCaptureBuffer = NULL;

  203.         delete fNetMidiPlaybackBuffer;

  204.         fNetMidiPlaybackBuffer = NULL;

  205.         FreePorts();

  206.         delete[] fMidiCapturePortList;

  207.         fMidiCapturePortList = NULL;

  208.         delete[] fMidiPlaybackPortList;

  209.         fMidiPlaybackPortList = NULL;

  210. #ifdef JACK_MONITOR

  211.         delete fNetTimeMon;

  212.         fNetTimeMon = NULL;

  213. #endif

  214.     }

  215. 

  216. //jack ports and buffers--------------------------------------------------------------

  217.     int JackNetDriver::AllocPorts()

  218.     {

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

  220. 

  221.         JackPort* port;

  222.         jack_port_id_t port_id;

  223.         char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  224.         char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  225.         unsigned long port_flags;

  226.         int audio_port_index;

  227.         uint midi_port_index;

  228. 

  229.         //audio

  230.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  232.         {

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

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

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

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

  237.             {

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

  239.                 return -1;

  240.             }

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

  242.             port->SetAlias ( alias );

  243.             //port latency

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

  245.             fCapturePortList[audio_port_index] = port_id;

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

  247.         }

  248.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  250.         {

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

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

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

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

  255.             {

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

  257.                 return -1;

  258.             }

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

  260.             port->SetAlias ( alias );

  261.             //port latency

  262.             switch ( fParams.fNetworkMode )

  263.             {

  264.                 case 'f' :

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

  266.                     break;

  267.                 case 'n' :

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

  269.                     break;

  270.                 case 's' :

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

  272.                     break;

  273.             }

  274.             fPlaybackPortList[audio_port_index] = port_id;

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

  276.         }

  277.         //midi

  278.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  280.         {

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

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

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

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

  285.             {

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

  287.                 return -1;

  288.             }

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

  290.             //port latency

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

  292.             fMidiCapturePortList[midi_port_index] = port_id;

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

  294.         }

  295. 

  296.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  298.         {

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

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

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

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

  303.             {

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

  305.                 return -1;

  306.             }

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

  308.             //port latency

  309.             switch ( fParams.fNetworkMode )

  310.             {

  311.                 case 'f' :

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

  313.                     break;

  314.                 case 'n' :

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

  316.                     break;

  317.                 case 's' :

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

  319.                     break;

  320.             }

  321.             fMidiPlaybackPortList[midi_port_index] = port_id;

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

  323.         }

  324. 

  325.         return 0;

  326.     }

  327. 

  328.     int JackNetDriver::FreePorts()

  329.     {

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

  331. 

  332.         int audio_port_index;

  333.         uint midi_port_index;

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

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

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

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

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

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

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

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

  342.         return 0;

  343.     }

  344. 

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

  346.     {

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

  348.     }

  349. 

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

  351.     {

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

  353.     }

  354. 

  355. //transport---------------------------------------------------------------------------

  356.     int JackNetDriver::DecodeTransportData()

  357.     {

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

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

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

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

  362.         int refnum;

  363.         bool conditional;

  364.         if ( fSendTransportData.fTimebaseMaster == TIMEBASEMASTER )

  365.         {

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

  367.             if ( refnum != -1 )

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

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

  370.         }

  371. 

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

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

  374.         {

  375.             switch ( fSendTransportData.fState )

  376.             {

  377.                 case JackTransportStopped :

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

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

  380.                     break;

  381.                     

  382.                 case JackTransportStarting :

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

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

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

  386.                     break;

  387.                     

  388.                 case JackTransportRolling :

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

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

  391.                     break;

  392.             }

  393.         }

  394. 

  395.         return 0;

  396.     }

  397. 

  398.     int JackNetDriver::EncodeTransportData()

  399.     {

  400.         //is there a timebase master change ?

  401.         int refnum;

  402.         bool conditional;

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

  404.         if ( refnum != fLastTimebaseMaster )

  405.         {

  406.             //timebase master has released its function

  407.             if ( refnum == -1 )

  408.             {

  409.                 fReturnTransportData.fTimebaseMaster = RELEASE_TIMEBASEMASTER;

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

  411.             }

  412.             //there is a new timebase master

  413.             else

  414.             {

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

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

  417.             }

  418.             fLastTimebaseMaster = refnum;

  419.         }

  420.         else

  421.             fReturnTransportData.fTimebaseMaster = NO_CHANGE;

  422. 

  423.         //update transport state and position

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

  425. 

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

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

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

  429.         if ( fReturnTransportData.fNewState )

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

  431.         fLastTransportState = fReturnTransportData.fState;

  432. 

  433.         return 0;

  434.     }

  435. 

  436. //network sync------------------------------------------------------------------------

  437.     int JackNetDriver::DecodeSyncPacket()

  438.     {

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

  440.         //first : transport

  441.         if ( fParams.fTransportSync )

  442.         {

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

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

  445.             if ( DecodeTransportData() < 0 )

  446.                 return -1;

  447.         }

  448.         //then others

  449.         //...

  450.         return 0;

  451.     }

  452. 

  453.     int JackNetDriver::EncodeSyncPacket()

  454.     {

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

  456.         //first of all, reset sync packet

  457.         memset ( fTxData, 0, fPayloadSize );

  458.         //then first step : transport

  459.         if ( fParams.fTransportSync )

  460.         {

  461.             if ( EncodeTransportData() < 0 )

  462.                 return -1;

  463.             //copy to TxBuffer

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

  465.         }

  466.         //then others

  467.         //...

  468.         return 0;

  469.     }

  470. 

  471. //driver processes--------------------------------------------------------------------

  472.     int JackNetDriver::Read()

  473.     {

  474.         uint midi_port_index;

  475.         uint audio_port_index;

  476. 

  477.         //buffers

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

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

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

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

  482. 

  483. #ifdef JACK_MONITOR

  484.         fNetTimeMon->New();

  485. #endif

  486. 

  487.         //receive sync (launch the cycle)

  488.         if ( SyncRecv() == SOCKET_ERROR )

  489.             return 0;

  490. 

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

  492.         JackDriver::CycleTakeBeginTime();

  493. 

  494.         //decode sync

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

  496.         if ( DecodeSyncPacket() < 0 )

  497.             return 0;

  498. 

  499. #ifdef JACK_MONITOR

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

  501. #endif

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

  503.         if ( DataRecv() == SOCKET_ERROR )

  504.             return SOCKET_ERROR;

  505. 

  506. #ifdef JACK_MONITOR

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

  508. #endif

  509. 

  510.         return 0;

  511.     }

  512. 

  513.     int JackNetDriver::Write()

  514.     {

  515.         uint midi_port_index;

  516.         int audio_port_index;

  517. 

  518.         //buffers

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

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

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

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

  523. 

  524. #ifdef JACK_MONITOR

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

  526. #endif

  527. 

  528.         //sync

  529.         if ( EncodeSyncPacket() < 0 )

  530.             return 0;

  531. 

  532.         //send sync

  533.         if ( SyncSend() == SOCKET_ERROR )

  534.             return SOCKET_ERROR;

  535. 

  536. #ifdef JACK_MONITOR

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

  538. #endif

  539. 

  540.         //send data

  541.         if ( DataSend() == SOCKET_ERROR )

  542.             return SOCKET_ERROR;

  543. 

  544. #ifdef JACK_MONITOR

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

  546. #endif

  547. 

  548.         return 0;

  549.     }

  550. 

  551. //driver loader-----------------------------------------------------------------------

  552. 

  553. #ifdef __cplusplus

  554.     extern "C"

  555.     {

  556. #endif

  557.         SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor ()

  558.         {

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

  560.             

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

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

  563.             

  564.             desc->nparams = 10;

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

  566. 

  567.             int i = 0;

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

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

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

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

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

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

  574. 

  575.             i++;

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

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

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

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

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

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

  582. 

  583.             i++;

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

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

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

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

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

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

  590. 

  591.             i++;

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

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

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

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

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

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

  598. 

  599.             i++;

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

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

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

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

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

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

  606. 

  607.             i++;

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

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

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

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

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

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

  614. 

  615.             i++;

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

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

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

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

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

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

  622. 

  623.             i++;

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

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

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

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

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

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

  630. 

  631.             i++;

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

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

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

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

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

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

  638. 

  639.             i++;

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

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

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

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

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

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

  646. 

  647.             return desc;

  648.         }

  649. 

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

  651.         {

  652.             char multicast_ip[16];

  653.             strcpy ( multicast_ip, DEFAULT_MULTICAST_IP );

  654.             char net_name[JACK_CLIENT_NAME_SIZE];

  655.             int udp_port = DEFAULT_PORT;

  656.             int mtu = 1500;

  657.             uint transport_sync = 1;

  658.             jack_nframes_t period_size = 128;

  659.             jack_nframes_t sample_rate = 48000;

  660.             int audio_capture_ports = 2;

  661.             int audio_playback_ports = 2;

  662.             int midi_input_ports = 0;

  663.             int midi_output_ports = 0;

  664.             bool monitor = false;

  665.             char network_mode = 'n';

  666.             const JSList* node;

  667.             const jack_driver_param_t* param;

  668.             

  669.             net_name[0] = 0;

  670.             

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

  672.             {

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

  674.                 switch ( param->character )

  675.                 {

  676.                     case 'a' :

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

  678.                         break;

  679.                     case 'p':

  680.                         udp_port = param->value.ui;

  681.                         break;

  682.                     case 'M':

  683.                         mtu = param->value.i;

  684.                         break;

  685.                     case 'C':

  686.                         audio_capture_ports = param->value.i;

  687.                         break;

  688.                     case 'P':

  689.                         audio_playback_ports = param->value.i;

  690.                         break;

  691.                     case 'i':

  692.                         midi_input_ports = param->value.i;

  693.                         break;

  694.                     case 'o':

  695.                         midi_output_ports = param->value.i;

  696.                         break;

  697.                     case 'n' :

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

  699.                         break;

  700.                     case 't' :

  701.                         transport_sync = param->value.ui;

  702.                         break;

  703.                     case 'm' :

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

  705.                             network_mode = 'n';

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

  707.                             network_mode = 's';

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

  709.                             network_mode = 'f';

  710.                         else

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

  712.                         break;

  713.                 }

  714.             }

  715. 

  716.             try {

  717.             

  718.                 Jack::JackDriverClientInterface* driver = 

  719.                     new Jack::JackWaitThreadedDriver(

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

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

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

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

  724.                     return driver;

  725.                 } else {

  726.                     delete driver;

  727.                     return NULL;

  728.                 }

  729.                 

  730.             } catch (...) {

  731.                 return NULL;

  732.             }   

  733.         }

  734. 

  735. #ifdef __cplusplus

  736.     }

  737. #endif

  738. }