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

734 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.                                    const 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.         fParams.fMtu = mtu;

  40.         fParams.fSendMidiChannels = midi_input_ports;

  41.         fParams.fReturnMidiChannels = midi_output_ports;

  42.         strcpy ( fParams.fName, net_name );

  43.         fSocket.GetName ( fParams.fSlaveNetName );

  44.         fParams.fTransportSync = transport_sync;

  45.         fParams.fNetworkMode = network_mode;

  46.         fLastTimebaseMaster = -1;

  47. #ifdef JACK_MONITOR

  48.         fNetTimeMon = NULL;

  49. #endif

  50.     }

  51. 

  52.     JackNetDriver::~JackNetDriver()

  53.     {

  54.         delete[] fMidiCapturePortList;

  55.         delete[] fMidiPlaybackPortList;

  56. #ifdef JACK_MONITOR

  57.         delete fNetTimeMon;

  58. #endif

  59.     }

  60. 

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

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

  63.                               int inchannels, int outchannels, bool monitor,

  64.                               const char* capture_driver_name, const char* playback_driver_name,

  65.                               jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  66.     {

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

  68.                                           capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  69.         fEngineControl->fPeriod = 0;

  70.         fEngineControl->fComputation = 500 * 1000;

  71.         fEngineControl->fConstraint = 500 * 1000;

  72.         return res;

  73.     }

  74. 

  75. #ifdef JACK_MONITOR

  76.     int JackNetDriver::Close()

  77.     {

  78.         if ( fNetTimeMon )

  79.             fNetTimeMon->Save();

  80.         return JackDriver::Close();

  81.     }

  82. #endif

  83. 

  84.     int JackNetDriver::Attach()

  85.     {

  86.         return 0;

  87.     }

  88. 

  89.     int JackNetDriver::Detach()

  90.     {

  91.         return 0;

  92.     }

  93. 

  94. //init and restart--------------------------------------------------------------------

  95.     bool JackNetDriver::Init()

  96.     {

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

  98. 

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

  100.         if ( fSocket.IsSocket() )

  101.             Restart();

  102. 

  103.         //set the parameters to send

  104.         fParams.fSendAudioChannels = fCaptureChannels;

  105.         fParams.fReturnAudioChannels = fPlaybackChannels;

  106.         fParams.fSlaveSyncMode = fEngineControl->fSyncMode;

  107. 

  108.         //display some additional infos

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

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

  111. 

  112.         //init network

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

  114.             return false;

  115. 

  116.         //set global paramaters

  117.         SetParams();

  118. 

  119.         //driver parametering

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

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

  122. 

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

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

  125. 

  126.         //transport engine parametering

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

  128. 

  129.         //allocate midi ports lists

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

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

  132. 

  133.         //register jack ports

  134.         if ( AllocPorts() != 0 )

  135.         {

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

  137.             return false;

  138.         }

  139. 

  140.         //init done, display parameters

  141.         SessionParamsDisplay ( &fParams );

  142. 

  143.         //monitor

  144. #ifdef JACK_MONITOR

  145.         string plot_name;

  146.         //NetTimeMon

  147.         plot_name = string ( fParams.fName );

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

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

  150.         switch ( fParams.fNetworkMode )

  151.         {

  152.             case 's' :

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

  154.                 break;

  155.                 

  156.             case 'n' :

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

  158.                 break;

  159.                 

  160.             case 'f' :

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

  162.                 break;

  163.         }

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

  165.         string net_time_mon_fields[] =

  166.         {

  167.             string ( "sync decoded" ),

  168.             string ( "end of read" ),

  169.             string ( "start of write" ),

  170.             string ( "sync send" ),

  171.             string ( "end of write" )

  172.         };

  173.         string net_time_mon_options[] =

  174.         {

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

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

  177.         };

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

  179. #endif

  180. 

  181.         return true;

  182.     }

  183. 

  184.     void JackNetDriver::Restart()

  185.     {

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

  187. 

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

  189.         delete[] fTxBuffer;

  190.         fTxBuffer = NULL;

  191.         delete[] fRxBuffer;

  192.         fRxBuffer = NULL;

  193.         delete fNetAudioCaptureBuffer;

  194.         fNetAudioCaptureBuffer = NULL;

  195.         delete fNetAudioPlaybackBuffer;

  196.         fNetAudioPlaybackBuffer = NULL;

  197.         delete fNetMidiCaptureBuffer;

  198.         fNetMidiCaptureBuffer = NULL;

  199.         delete fNetMidiPlaybackBuffer;

  200.         fNetMidiPlaybackBuffer = NULL;

  201.         FreePorts();

  202.         delete[] fMidiCapturePortList;

  203.         fMidiCapturePortList = NULL;

  204.         delete[] fMidiPlaybackPortList;

  205.         fMidiPlaybackPortList = NULL;

  206. #ifdef JACK_MONITOR

  207.         delete fNetTimeMon;

  208.         fNetTimeMon = NULL;

  209. #endif

  210.     }

  211. 

  212. //jack ports and buffers--------------------------------------------------------------

  213.     int JackNetDriver::AllocPorts()

  214.     {

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

  216. 

  217.         JackPort* port;

  218.         jack_port_id_t port_id;

  219.         char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  220.         char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  221.         unsigned long port_flags;

  222.         int audio_port_index;

  223.         uint midi_port_index;

  224. 

  225.         //audio

  226.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  228.         {

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

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

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

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

  233.             {

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

  235.                 return -1;

  236.             }

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

  238.             port->SetAlias ( alias );

  239.             //port latency

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

  241.             fCapturePortList[audio_port_index] = port_id;

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

  243.         }

  244.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  246.         {

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

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

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

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

  251.             {

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

  253.                 return -1;

  254.             }

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

  256.             port->SetAlias ( alias );

  257.             //port latency

  258.             switch ( fParams.fNetworkMode )

  259.             {

  260.                 case 'f' :

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

  262.                     break;

  263.                 case 'n' :

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

  265.                     break;

  266.                 case 's' :

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

  268.                     break;

  269.             }

  270.             fPlaybackPortList[audio_port_index] = port_id;

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

  272.         }

  273.         //midi

  274.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  276.         {

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

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

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

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

  281.             {

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

  283.                 return -1;

  284.             }

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

  286.             //port latency

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

  288.             fMidiCapturePortList[midi_port_index] = port_id;

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

  290.         }

  291. 

  292.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  294.         {

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

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

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

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

  299.             {

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

  301.                 return -1;

  302.             }

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

  304.             //port latency

  305.             switch ( fParams.fNetworkMode )

  306.             {

  307.                 case 'f' :

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

  309.                     break;

  310.                 case 'n' :

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

  312.                     break;

  313.                 case 's' :

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

  315.                     break;

  316.             }

  317.             fMidiPlaybackPortList[midi_port_index] = port_id;

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

  319.         }

  320. 

  321.         return 0;

  322.     }

  323. 

  324.     int JackNetDriver::FreePorts()

  325.     {

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

  327. 

  328.         int audio_port_index;

  329.         uint midi_port_index;

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

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

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

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

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

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

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

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

  338.         return 0;

  339.     }

  340. 

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

  342.     {

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

  344.     }

  345. 

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

  347.     {

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

  349.     }

  350. 

  351. //transport---------------------------------------------------------------------------

  352.     int JackNetDriver::DecodeTransportData()

  353.     {

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

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

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

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

  358.         int refnum;

  359.         bool conditional;

  360.         if ( fSendTransportData.fTimebaseMaster == TIMEBASEMASTER )

  361.         {

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

  363.             if ( refnum != -1 )

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

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

  366.         }

  367. 

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

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

  370.         {

  371.             switch ( fSendTransportData.fState )

  372.             {

  373.                 case JackTransportStopped :

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

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

  376.                     break;

  377.                     

  378.                 case JackTransportStarting :

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

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

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

  382.                     break;

  383.                     

  384.                 case JackTransportRolling :

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

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

  387.                     break;

  388.             }

  389.         }

  390. 

  391.         return 0;

  392.     }

  393. 

  394.     int JackNetDriver::EncodeTransportData()

  395.     {

  396.         //is there a timebase master change ?

  397.         int refnum;

  398.         bool conditional;

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

  400.         if ( refnum != fLastTimebaseMaster )

  401.         {

  402.             //timebase master has released its function

  403.             if ( refnum == -1 )

  404.             {

  405.                 fReturnTransportData.fTimebaseMaster = RELEASE_TIMEBASEMASTER;

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

  407.             }

  408.             //there is a new timebase master

  409.             else

  410.             {

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

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

  413.             }

  414.             fLastTimebaseMaster = refnum;

  415.         }

  416.         else

  417.             fReturnTransportData.fTimebaseMaster = NO_CHANGE;

  418. 

  419.         //update transport state and position

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

  421. 

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

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

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

  425.         if ( fReturnTransportData.fNewState )

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

  427.         fLastTransportState = fReturnTransportData.fState;

  428. 

  429.         return 0;

  430.     }

  431. 

  432. //network sync------------------------------------------------------------------------

  433.     int JackNetDriver::DecodeSyncPacket()

  434.     {

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

  436.         //first : transport

  437.         if ( fParams.fTransportSync )

  438.         {

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

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

  441.             if ( DecodeTransportData() < 0 )

  442.                 return -1;

  443.         }

  444.         //then others

  445.         //...

  446.         return 0;

  447.     }

  448. 

  449.     int JackNetDriver::EncodeSyncPacket()

  450.     {

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

  452.         //first of all, reset sync packet

  453.         memset ( fTxData, 0, fPayloadSize );

  454.         //then first step : transport

  455.         if ( fParams.fTransportSync )

  456.         {

  457.             if ( EncodeTransportData() < 0 )

  458.                 return -1;

  459.             //copy to TxBuffer

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

  461.         }

  462.         //then others

  463.         //...

  464.         return 0;

  465.     }

  466. 

  467. //driver processes--------------------------------------------------------------------

  468.     int JackNetDriver::Read()

  469.     {

  470.         uint midi_port_index;

  471.         uint audio_port_index;

  472. 

  473.         //buffers

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

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

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

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

  478. 

  479. #ifdef JACK_MONITOR

  480.         fNetTimeMon->New();

  481. #endif

  482. 

  483.         //receive sync (launch the cycle)

  484.         if ( SyncRecv() == SOCKET_ERROR )

  485.             return 0;

  486. 

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

  488.         JackDriver::CycleTakeBeginTime();

  489. 

  490.         //decode sync

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

  492.         if ( DecodeSyncPacket() < 0 )

  493.             return 0;

  494. 

  495. #ifdef JACK_MONITOR

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

  497. #endif

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

  499.         if ( DataRecv() == SOCKET_ERROR )

  500.             return SOCKET_ERROR;

  501. 

  502. #ifdef JACK_MONITOR

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

  504. #endif

  505. 

  506.         return 0;

  507.     }

  508. 

  509.     int JackNetDriver::Write()

  510.     {

  511.         uint midi_port_index;

  512.         int audio_port_index;

  513. 

  514.         //buffers

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

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

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

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

  519. 

  520. #ifdef JACK_MONITOR

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

  522. #endif

  523. 

  524.         //sync

  525.         if ( EncodeSyncPacket() < 0 )

  526.             return 0;

  527. 

  528.         //send sync

  529.         if ( SyncSend() == SOCKET_ERROR )

  530.             return SOCKET_ERROR;

  531. 

  532. #ifdef JACK_MONITOR

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

  534. #endif

  535. 

  536.         //send data

  537.         if ( DataSend() == SOCKET_ERROR )

  538.             return SOCKET_ERROR;

  539. 

  540. #ifdef JACK_MONITOR

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

  542. #endif

  543. 

  544.         return 0;

  545.     }

  546. 

  547. //driver loader-----------------------------------------------------------------------

  548. 

  549. #ifdef __cplusplus

  550.     extern "C"

  551.     {

  552. #endif

  553.         EXPORT jack_driver_desc_t* driver_get_descriptor ()

  554.         {

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

  556.             

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

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

  559.             

  560.             desc->nparams = 10;

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

  562. 

  563.             int i = 0;

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

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

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

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

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

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

  570. 

  571.             i++;

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

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

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

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

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

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

  578. 

  579.             i++;

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

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

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

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

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

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

  586. 

  587.             i++;

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

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

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

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

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

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

  594. 

  595.             i++;

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

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

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

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

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

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

  602. 

  603.             i++;

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

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

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

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

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

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

  610. 

  611.             i++;

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

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

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

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

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

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

  618. 

  619.             i++;

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

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

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

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

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

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

  626. 

  627.             i++;

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

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

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

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

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

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

  634. 

  635.             i++;

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

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

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

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

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

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

  642. 

  643.             return desc;

  644.         }

  645. 

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

  647.         {

  648.             char multicast_ip[16];

  649.             strcpy ( multicast_ip, DEFAULT_MULTICAST_IP );

  650.             char name[JACK_CLIENT_NAME_SIZE];

  651.             GetHostName ( name, JACK_CLIENT_NAME_SIZE );

  652.             int udp_port = DEFAULT_PORT;

  653.             int mtu = 1500;

  654.             uint transport_sync = 1;

  655.             jack_nframes_t period_size = 128;

  656.             jack_nframes_t sample_rate = 48000;

  657.             int audio_capture_ports = 2;

  658.             int audio_playback_ports = 2;

  659.             int midi_input_ports = 0;

  660.             int midi_output_ports = 0;

  661.             bool monitor = false;

  662.             char network_mode = 'n';

  663. 

  664.             const JSList* node;

  665.             const jack_driver_param_t* param;

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

  667.             {

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

  669.                 switch ( param->character )

  670.                 {

  671.                     case 'a' :

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

  673.                         break;

  674.                     case 'p':

  675.                         udp_port = param->value.ui;

  676.                         break;

  677.                     case 'M':

  678.                         mtu = param->value.i;

  679.                         break;

  680.                     case 'C':

  681.                         audio_capture_ports = param->value.i;

  682.                         break;

  683.                     case 'P':

  684.                         audio_playback_ports = param->value.i;

  685.                         break;

  686.                     case 'i':

  687.                         midi_input_ports = param->value.i;

  688.                         break;

  689.                     case 'o':

  690.                         midi_output_ports = param->value.i;

  691.                         break;

  692.                     case 'n' :

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

  694.                         break;

  695.                     case 't' :

  696.                         transport_sync = param->value.ui;

  697.                         break;

  698.                     case 'm' :

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

  700.                             network_mode = 'n';

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

  702.                             network_mode = 's';

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

  704.                             network_mode = 'f';

  705.                         else

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

  707.                         break;

  708.                 }

  709.             }

  710. 

  711.             try {

  712.             

  713.                 Jack::JackDriverClientInterface* driver = 

  714.                     new Jack::JackWaitThreadedDriver(

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

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

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

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

  719.                     return driver;

  720.                 } else {

  721.                     delete driver;

  722.                     return NULL;

  723.                 }

  724.                 

  725.             } catch (...) {

  726.                 return NULL;

  727.             }   

  728.         }

  729. 

  730. #ifdef __cplusplus

  731.     }

  732. #endif

  733. }