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

825 lines
33KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2001 Paul Davis

  3. Copyright (C) 2008 Romain Moret at Grame

  4. 

  5. This program is free software; you can redistribute it and/or modify

  6. it under the terms of the GNU General Public License as published by

  7. the Free Software Foundation; either version 2 of the License, or

  8. (at your option) any later version.

  9. 

  10. This program is distributed in the hope that it will be useful,

  11. but WITHOUT ANY WARRANTY; without even the implied warranty of

  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13. GNU General Public License for more details.

  14. 

  15. You should have received a copy of the GNU General Public License

  16. along with this program; if not, write to the Free Software

  17. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  18. 

  19. */

  20. 

  21. #include "JackNetDriver.h"

  22. #include "JackEngineControl.h"

  23. #include "JackClientControl.h"

  24. #include "JackGraphManager.h"

  25. #include "JackDriverLoader.h"

  26. #include "JackThreadedDriver.h"

  27. #include "JackWaitThreadedDriver.h"

  28. #include "JackException.h"

  29. 

  30. #define DEFAULT_MULTICAST_IP "225.3.19.154"

  31. #define DEFAULT_PORT 19000

  32. 

  33. using namespace std;

  34. 

  35. namespace Jack

  36. {

  37. #ifdef JACK_MONITOR

  38.     uint JackNetDriver::fMeasureCnt = 128;

  39.     uint JackNetDriver::fMeasurePoints = 5;

  40.     uint JackNetDriver::fMonitorPlotOptionsCnt = 2;

  41.     string JackNetDriver::fMonitorPlotOptions[] =

  42.     {

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

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

  45.     };

  46.     string JackNetDriver::fMonitorFieldNames[] =

  47.     {

  48.         string ( "cyclestart" ),

  49.         string ( "read end" ),

  50.         string ( "write start" ),

  51.         string ( "sync send" ),

  52.         string ( "send end" )

  53.     };

  54. #endif

  55. 

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

  57.                                    const char* ip, int port, int mtu, int midi_input_ports, int midi_output_ports, const char* net_name, uint transport_sync )

  58.             : JackAudioDriver ( name, alias, engine, table ), fSocket ( ip, port )

  59.     {

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

  61. 

  62.         fMulticastIP = new char[strlen ( ip ) + 1];

  63.         strcpy ( fMulticastIP, ip );

  64.         fParams.fMtu = mtu;

  65.         fParams.fSendMidiChannels = midi_input_ports;

  66.         fParams.fReturnMidiChannels = midi_output_ports;

  67.         strcpy ( fParams.fName, net_name );

  68.         fSocket.GetName ( fParams.fSlaveNetName );

  69.         fParams.fTransportSync = transport_sync;

  70.     }

  71. 

  72.     JackNetDriver::~JackNetDriver()

  73.     {

  74.         fSocket.Close();

  75.         SocketAPIEnd();

  76.         delete fNetAudioCaptureBuffer;

  77.         delete fNetAudioPlaybackBuffer;

  78.         delete fNetMidiCaptureBuffer;

  79.         delete fNetMidiPlaybackBuffer;

  80.         delete[] fTxBuffer;

  81.         delete[] fRxBuffer;

  82.         delete[] fMulticastIP;

  83.         delete[] fMidiCapturePortList;

  84.         delete[] fMidiPlaybackPortList;

  85. #ifdef JACK_MONITOR

  86.         fMonitor->Save();

  87.         delete[] fMeasure;

  88.         delete fMonitor;

  89. #endif

  90.     }

  91. 

  92. //*************************************initialization***********************************************************************

  93. 

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

  95.                               int inchannels, int outchannels, bool monitor,

  96.                               const char* capture_driver_name, const char* playback_driver_name,

  97.                               jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  98.     {

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

  100.                                           capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  101.         fEngineControl->fPeriod = 0;

  102.         fEngineControl->fComputation = 500 * 1000;

  103.         fEngineControl->fConstraint = 500 * 1000;

  104.         return res;

  105.     }

  106. 

  107. #ifdef JACK_MONITOR

  108.     int JackNetDriver::Close()

  109.     {

  110.         fMonitor->Save();

  111.         return JackDriver::Close();

  112.     }

  113. #endif

  114. 

  115.     int JackNetDriver::Attach()

  116.     {

  117.         return 0;

  118.     }

  119. 

  120.     int JackNetDriver::Detach()

  121.     {

  122.         return 0;

  123.     }

  124. 

  125.     bool JackNetDriver::Init()

  126.     {

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

  128. 

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

  130.         if ( fSocket.IsSocket() )

  131.             Restart();

  132. 

  133.         //set the parameters to send

  134.         strcpy ( fParams.fPacketType, "params" );

  135.         fParams.fProtocolVersion = 'a';

  136.         SetPacketType ( &fParams, SLAVE_AVAILABLE );

  137.         fParams.fSendAudioChannels = fCaptureChannels;

  138.         fParams.fReturnAudioChannels = fPlaybackChannels;

  139. 

  140.         //is transport sync ?

  141.         if ( fParams.fTransportSync )

  142.             jack_info ( "NetDriver started with Master's Transport Sync." );

  143. 

  144.         //init loop : get a master and start, do it until connection is ok

  145.         net_status_t status;

  146.         do

  147.         {

  148.             //first, get a master, do it until a valid connection is running

  149.             jack_info ( "Initializing Net Driver..." );

  150.             do

  151.             {

  152.                 status = GetNetMaster();

  153.                 if ( status == NET_SOCKET_ERROR )

  154.                     return false;

  155.             }

  156.             while ( status != NET_CONNECTED );

  157. 

  158.             //then tell the master we are ready

  159.             jack_info ( "Initializing connection with %s...", fParams.fMasterNetName );

  160.             status = SendMasterStartSync();

  161.             if ( status == NET_ERROR )

  162.                 return false;

  163.         }

  164.         while ( status != NET_ROLLING );

  165. 

  166.         //driver parametering

  167.         if ( SetParams() )

  168.         {

  169.             jack_error ( "Fatal error : can't alloc net driver ports." );

  170.             return false;

  171.         }

  172. 

  173.         //init done, display parameters

  174.         SessionParamsDisplay ( &fParams );

  175. 

  176.         return true;

  177.     }

  178. 

  179.     net_status_t JackNetDriver::GetNetMaster()

  180.     {

  181.         jack_log ( "JackNetDriver::GetNetMaster()" );

  182.         //utility

  183.         session_params_t params;

  184.         int ms_timeout = 2000;

  185.         int rx_bytes = 0;

  186. 

  187.         //socket

  188.         if ( fSocket.NewSocket() == SOCKET_ERROR )

  189.         {

  190.             jack_error ( "Fatal error : network unreachable - %s", StrError ( NET_ERROR_CODE ) );

  191.             return NET_SOCKET_ERROR;

  192.         }

  193. 

  194.         //bind the socket

  195.         if ( fSocket.Bind() == SOCKET_ERROR )

  196.             jack_error ( "Can't bind the socket : %s", StrError ( NET_ERROR_CODE ) );

  197. 

  198.         //timeout on receive

  199.         if ( fSocket.SetTimeOut ( ms_timeout ) == SOCKET_ERROR )

  200.             jack_error ( "Can't set timeout : %s", StrError ( NET_ERROR_CODE ) );

  201. 

  202.         //send 'AVAILABLE' until 'SLAVE_SETUP' received

  203.         jack_info ( "Waiting for a master..." );

  204.         do

  205.         {

  206.             //send 'available'

  207.             if ( fSocket.SendTo ( &fParams, sizeof ( session_params_t ), 0, fMulticastIP ) == SOCKET_ERROR )

  208.                 jack_error ( "Error in data send : %s", StrError ( NET_ERROR_CODE ) );

  209.             //filter incoming packets : don't exit while receiving wrong packets

  210.             do

  211.             {

  212.                 rx_bytes = fSocket.CatchHost ( &params, sizeof ( session_params_t ), 0 );

  213.                 if ( ( rx_bytes == SOCKET_ERROR ) && ( fSocket.GetError() != NET_NO_DATA ) )

  214.                 {

  215.                     jack_error ( "Can't receive : %s", StrError ( NET_ERROR_CODE ) );

  216.                     return NET_RECV_ERROR;

  217.                 }

  218.             }

  219.             while ( ( rx_bytes > 0 )  && strcmp ( params.fPacketType, fParams.fPacketType ) );

  220.         }

  221.         while ( ( GetPacketType ( &params ) != SLAVE_SETUP ) );

  222. 

  223.         //connect the socket

  224.         if ( fSocket.Connect() == SOCKET_ERROR )

  225.         {

  226.             jack_error ( "Error in connect : %s", StrError ( NET_ERROR_CODE ) );

  227.             return NET_CONNECT_ERROR;

  228.         }

  229. 

  230.         //everything is OK, copy parameters and return

  231.         fParams = params;

  232. 

  233.         return NET_CONNECTED;

  234.     }

  235. 

  236.     net_status_t JackNetDriver::SendMasterStartSync()

  237.     {

  238.         jack_log ( "JackNetDriver::GetNetMasterStartSync()" );

  239.         //tell the master to start

  240.         SetPacketType ( &fParams, START_MASTER );

  241.         if ( fSocket.Send ( &fParams, sizeof ( session_params_t ), 0 ) == SOCKET_ERROR )

  242.         {

  243.             jack_error ( "Error in send : %s", StrError ( NET_ERROR_CODE ) );

  244.             return ( fSocket.GetError() == NET_CONN_ERROR ) ? NET_ERROR : NET_SEND_ERROR;

  245.         }

  246.         return NET_ROLLING;

  247.     }

  248. 

  249.     void JackNetDriver::Restart()

  250.     {

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

  252.         delete[] fTxBuffer;

  253.         fTxBuffer = NULL;

  254.         delete[] fRxBuffer;

  255.         fRxBuffer = NULL;

  256.         delete fNetAudioCaptureBuffer;

  257.         fNetAudioCaptureBuffer = NULL;

  258.         delete fNetAudioPlaybackBuffer;

  259.         fNetAudioPlaybackBuffer = NULL;

  260.         delete fNetMidiCaptureBuffer;

  261.         fNetMidiCaptureBuffer = NULL;

  262.         delete fNetMidiPlaybackBuffer;

  263.         fNetMidiPlaybackBuffer = NULL;

  264.         FreePorts();

  265.         delete[] fMidiCapturePortList;

  266.         fMidiCapturePortList = NULL;

  267.         delete[] fMidiPlaybackPortList;

  268.         fMidiPlaybackPortList = NULL;

  269. #ifdef JACK_MONITOR

  270.         delete[] fMeasure;

  271.         fMeasure = NULL;

  272.         delete fMonitor;

  273.         fMonitor = NULL;

  274. #endif

  275.     }

  276. 

  277.     int JackNetDriver::SetParams()

  278.     {

  279.         fNSubProcess = fParams.fPeriodSize / fParams.fFramesPerPacket;

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

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

  282. 

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

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

  285. 

  286.         //allocate midi ports lists

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

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

  289. 

  290.         //register jack ports

  291.         if ( AllocPorts() != 0 )

  292.         {

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

  294.             return -1;

  295.         }

  296. 

  297.         //TX header init

  298.         strcpy ( fTxHeader.fPacketType, "header" );

  299.         fTxHeader.fDataStream = 'r';

  300.         fTxHeader.fID = fParams.fID;

  301.         fTxHeader.fCycle = 0;

  302.         fTxHeader.fSubCycle = 0;

  303.         fTxHeader.fMidiDataSize = 0;

  304.         fTxHeader.fBitdepth = fParams.fBitdepth;

  305. 

  306.         //RX header init

  307.         strcpy ( fRxHeader.fPacketType, "header" );

  308.         fRxHeader.fDataStream = 's';

  309.         fRxHeader.fID = fParams.fID;

  310.         fRxHeader.fCycle = 0;

  311.         fRxHeader.fSubCycle = 0;

  312.         fRxHeader.fMidiDataSize = 0;

  313.         fRxHeader.fBitdepth = fParams.fBitdepth;

  314. 

  315.         //network buffers

  316.         fTxBuffer = new char[fParams.fMtu];

  317.         fRxBuffer = new char[fParams.fMtu];

  318. 

  319.         //net audio/midi buffers

  320.         fTxData = fTxBuffer + sizeof ( packet_header_t );

  321.         fRxData = fRxBuffer + sizeof ( packet_header_t );

  322. 

  323.         //midi net buffers

  324.         fNetMidiCaptureBuffer = new NetMidiBuffer ( &fParams, fParams.fSendMidiChannels, fRxData );

  325.         fNetMidiPlaybackBuffer = new NetMidiBuffer ( &fParams, fParams.fReturnMidiChannels, fTxData );

  326. 

  327.         //audio net buffers

  328.         fNetAudioCaptureBuffer = new NetAudioBuffer ( &fParams, fParams.fSendAudioChannels, fRxData );

  329.         fNetAudioPlaybackBuffer = new NetAudioBuffer ( &fParams, fParams.fReturnAudioChannels, fTxData );

  330. 

  331.         //audio netbuffer length

  332.         fAudioTxLen = sizeof ( packet_header_t ) + fNetAudioPlaybackBuffer->GetSize();

  333.         fAudioRxLen = sizeof ( packet_header_t ) + fNetAudioCaptureBuffer->GetSize();

  334. 

  335.         //payload size

  336.         fPayloadSize = fParams.fMtu - sizeof ( packet_header_t );

  337. 

  338.         //monitor

  339. #ifdef JACK_MONITOR

  340.         string plot_name = string ( fParams.fName );

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

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

  343.         fMonitor = new JackGnuPlotMonitor<float> ( JackNetDriver::fMeasureCnt, JackNetDriver::fMeasurePoints, plot_name );

  344.         fMeasure = new float[JackNetDriver::fMeasurePoints];

  345.         fMonitor->SetPlotFile ( JackNetDriver::fMonitorPlotOptions, JackNetDriver::fMonitorPlotOptionsCnt,

  346.                                 JackNetDriver::fMonitorFieldNames, JackNetDriver::fMeasurePoints );

  347. #endif

  348. 

  349.         return 0;

  350.     }

  351. 

  352.     int JackNetDriver::AllocPorts()

  353.     {

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

  355.         JackPort* port;

  356.         jack_port_id_t port_id;

  357.         char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  358.         char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  359.         unsigned long port_flags;

  360.         int audio_port_index;

  361.         uint midi_port_index;

  362. 

  363.         //audio

  364.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  366.         {

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

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

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

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

  371.             {

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

  373.                 return -1;

  374.             }

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

  376.             port->SetAlias ( alias );

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

  378.             fCapturePortList[audio_port_index] = port_id;

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

  380.         }

  381.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  383.         {

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

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

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

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

  388.             {

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

  390.                 return -1;

  391.             }

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

  393.             port->SetAlias ( alias );

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

  395.             fPlaybackPortList[audio_port_index] = port_id;

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

  397.         }

  398.         //midi

  399.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  401.         {

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

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

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

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

  406.             {

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

  408.                 return -1;

  409.             }

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

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

  412.             fMidiCapturePortList[midi_port_index] = port_id;

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

  414.         }

  415. 

  416.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  418.         {

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

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

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

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

  423.             {

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

  425.                 return -1;

  426.             }

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

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

  429.             fMidiPlaybackPortList[midi_port_index] = port_id;

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

  431.         }

  432. 

  433.         return 0;

  434.     }

  435. 

  436.     int JackNetDriver::FreePorts()

  437.     {

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

  439.         int audio_port_index;

  440.         uint midi_port_index;

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

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

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

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

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

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

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

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

  449.         return 0;

  450.     }

  451. 

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

  453.     {

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

  455.     }

  456. 

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

  458.     {

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

  460.     }

  461. 

  462.     int JackNetDriver::SetSyncPacket()

  463.     {

  464.         if ( fParams.fTransportSync )

  465.         {

  466.             //set the TransportData

  467. 

  468.             //copy to TxBuffer

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

  470.         }

  471.         return 0;

  472.     }

  473. 

  474.     int JackNetDriver::Recv ( size_t size, int flags )

  475.     {

  476.         int rx_bytes;

  477.         if ( ( rx_bytes = fSocket.Recv ( fRxBuffer, size, flags ) ) == SOCKET_ERROR )

  478.         {

  479.             net_error_t error = fSocket.GetError();

  480.             if ( error == NET_NO_DATA )

  481.             {

  482.                 jack_error ( "No incoming data, is the master still running ?" );

  483.                 return 0;

  484.             }

  485.             else if ( error == NET_CONN_ERROR )

  486.             {

  487.                 throw JackDriverException ( "Connection lost." );

  488.             }

  489.             else

  490.             {

  491.                 jack_error ( "Error in receive : %s", StrError ( NET_ERROR_CODE ) );

  492.                 return 0;

  493.             }

  494.         }

  495.         return rx_bytes;

  496.     }

  497. 

  498.     int JackNetDriver::Send ( size_t size, int flags )

  499.     {

  500.         int tx_bytes;

  501.         if ( ( tx_bytes = fSocket.Send ( fTxBuffer, size, flags ) ) == SOCKET_ERROR )

  502.         {

  503.             net_error_t error = fSocket.GetError();

  504.             if ( error == NET_CONN_ERROR )

  505.                 throw JackDriverException ( "Connection lost." );

  506.             else

  507.                 jack_error ( "Error in send : %s", StrError ( NET_ERROR_CODE ) );

  508.         }

  509.         return tx_bytes;

  510.     }

  511. 

  512. //*************************************process************************************************************************

  513. 

  514.     int JackNetDriver::Read()

  515.     {

  516.         int rx_bytes;

  517.         uint recvd_midi_pckt = 0;

  518.         packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer );

  519.         fRxHeader.fIsLastPckt = 'n';

  520.         uint midi_port_index;

  521.         int audio_port_index;

  522. 

  523.         //buffers

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

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

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

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

  528. 

  529.         //receive sync (launch the cycle)

  530.         do

  531.         {

  532.             rx_bytes = Recv ( fParams.fMtu, 0 );

  533.             if ( ( rx_bytes == 0 ) || ( rx_bytes == SOCKET_ERROR ) )

  534.                 return rx_bytes;

  535.         }

  536.         while ( !rx_bytes && ( rx_head->fDataType != 's' ) );

  537. 

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

  539.         JackDriver::CycleTakeBeginTime();

  540. 

  541. #ifdef JACK_MONITOR

  542.         fMeasureId = 0;

  543.         fMeasure[fMeasureId++] = ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f;

  544. #endif

  545. 

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

  547.         if ( fParams.fSendMidiChannels || fParams.fSendAudioChannels )

  548.         {

  549.             do

  550.             {

  551.                 if ( ( rx_bytes = Recv ( fParams.fMtu, MSG_PEEK ) ) == SOCKET_ERROR )

  552.                     return rx_bytes;

  553.                 if ( rx_bytes && ( rx_head->fDataStream == 's' ) && ( rx_head->fID == fParams.fID ) )

  554.                 {

  555.                     switch ( rx_head->fDataType )

  556.                     {

  557.                         case 'm':   //midi

  558.                             rx_bytes = Recv ( rx_bytes, 0 );

  559.                             fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

  560.                             fNetMidiCaptureBuffer->RenderFromNetwork ( rx_head->fSubCycle, rx_bytes - sizeof ( packet_header_t ) );

  561.                             if ( ++recvd_midi_pckt == rx_head->fNMidiPckt )

  562.                                 fNetMidiCaptureBuffer->RenderToJackPorts();

  563.                             break;

  564.                         case 'a':   //audio

  565.                             rx_bytes = Recv ( fAudioRxLen, 0 );

  566.                             if ( !IsNextPacket ( &fRxHeader, rx_head, fNSubProcess ) )

  567.                                 jack_error ( "Packet(s) missing..." );

  568.                             fRxHeader.fCycle = rx_head->fCycle;

  569.                             fRxHeader.fSubCycle = rx_head->fSubCycle;

  570.                             fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

  571.                             fNetAudioCaptureBuffer->RenderToJackPorts ( rx_head->fSubCycle );

  572.                             break;

  573.                         case 's':   //sync

  574.                             jack_info ( "NetDriver : driver overloaded, skipping receive." );

  575.                             fRxHeader.fCycle = rx_head->fCycle;

  576.                             return 0;

  577.                     }

  578.                 }

  579.             }

  580.             while ( fRxHeader.fIsLastPckt != 'y' );

  581.         }

  582.         fRxHeader.fCycle = rx_head->fCycle;

  583. 

  584. 

  585. #ifdef JACK_MONITOR

  586.         fMeasure[fMeasureId++] = ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f;

  587. #endif

  588. 

  589.         return 0;

  590.     }

  591. 

  592.     int JackNetDriver::Write()

  593.     {

  594.         int tx_bytes, copy_size;

  595.         if ( fEngineControl->fSyncMode )

  596.             fTxHeader.fCycle = fRxHeader.fCycle;

  597.         else

  598.             fTxHeader.fCycle++;

  599.         fTxHeader.fSubCycle = 0;

  600.         fTxHeader.fIsLastPckt = 'n';

  601.         uint midi_port_index;

  602.         int audio_port_index;

  603. 

  604.         //buffers

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

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

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

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

  609. 

  610. #ifdef JACK_MONITOR

  611.         fMeasure[fMeasureId++] = ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f;

  612. #endif

  613. 

  614.         //sync

  615.         fTxHeader.fDataType = 's';

  616.         if ( !fParams.fSendMidiChannels && !fParams.fSendAudioChannels )

  617.             fTxHeader.fIsLastPckt = 'y';

  618.         memset ( fTxData, 0, fPayloadSize );

  619.         SetSyncPacket();

  620.         tx_bytes = Send ( fParams.fMtu, 0 );

  621. 

  622. #ifdef JACK_MONITOR

  623.         fMeasure[fMeasureId++] = ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f;

  624. #endif

  625. 

  626.         //midi

  627.         if ( fParams.fReturnMidiChannels )

  628.         {

  629.             fTxHeader.fDataType = 'm';

  630.             fTxHeader.fMidiDataSize = fNetMidiPlaybackBuffer->RenderFromJackPorts();

  631.             fTxHeader.fNMidiPckt = GetNMidiPckt ( &fParams, fTxHeader.fMidiDataSize );

  632.             for ( uint subproc = 0; subproc < fTxHeader.fNMidiPckt; subproc++ )

  633.             {

  634.                 fTxHeader.fSubCycle = subproc;

  635.                 if ( ( subproc == ( fTxHeader.fNMidiPckt - 1 ) ) && !fParams.fReturnAudioChannels )

  636.                     fTxHeader.fIsLastPckt = 'y';

  637.                 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );

  638.                 copy_size = fNetMidiPlaybackBuffer->RenderToNetwork ( subproc, fTxHeader.fMidiDataSize );

  639.                 tx_bytes = Send ( sizeof ( packet_header_t ) + copy_size, 0 );

  640.             }

  641.         }

  642. 

  643.         //audio

  644.         if ( fParams.fReturnAudioChannels )

  645.         {

  646.             fTxHeader.fDataType = 'a';

  647.             for ( uint subproc = 0; subproc < fNSubProcess; subproc++ )

  648.             {

  649.                 fTxHeader.fSubCycle = subproc;

  650.                 if ( subproc == ( fNSubProcess - 1 ) )

  651.                     fTxHeader.fIsLastPckt = 'y';

  652.                 fNetAudioPlaybackBuffer->RenderFromJackPorts ( subproc );

  653.                 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) );

  654.                 tx_bytes = Send ( fAudioTxLen, 0 );

  655.             }

  656.         }

  657. 

  658. #ifdef JACK_MONITOR

  659.         fMeasure[fMeasureId++] = ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f;

  660.         fMonitor->Write ( fMeasure );

  661. #endif

  662. 

  663.         return 0;

  664.     }

  665. 

  666. //*************************************loader*******************************************************

  667. 

  668. #ifdef __cplusplus

  669.     extern "C"

  670.     {

  671. #endif

  672.         EXPORT jack_driver_desc_t* driver_get_descriptor ()

  673.         {

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

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

  676.             desc->nparams = 9;

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

  678. 

  679.             int i = 0;

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

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

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

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

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

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

  686. 

  687.             i++;

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

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

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

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

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

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

  694. 

  695.             i++;

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

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

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

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

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

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

  702. 

  703.             i++;

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

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

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

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

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

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

  710. 

  711.             i++;

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

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

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

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

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

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

  718. 

  719.             i++;

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

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

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

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

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

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

  726. 

  727.             i++;

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

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

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

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

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

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

  734. 

  735.             i++;

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

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

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

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

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

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

  742. 

  743.             i++;

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

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

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

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

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

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

  750. 

  751.             return desc;

  752.         }

  753. 

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

  755.         {

  756.             if ( SocketAPIInit() < 0 )

  757.             {

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

  759.                 return NULL;

  760.             }

  761.             const char* multicast_ip = DEFAULT_MULTICAST_IP;

  762.             char name[JACK_CLIENT_NAME_SIZE];

  763.             GetHostName ( name, JACK_CLIENT_NAME_SIZE );

  764.             int udp_port = DEFAULT_PORT;

  765.             int mtu = 1500;

  766.             uint transport_sync = 1;

  767.             jack_nframes_t period_size = 128;

  768.             jack_nframes_t sample_rate = 48000;

  769.             int audio_capture_ports = 2;

  770.             int audio_playback_ports = 2;

  771.             int midi_input_ports = 0;

  772.             int midi_output_ports = 0;

  773.             bool monitor = false;

  774. 

  775.             const JSList* node;

  776.             const jack_driver_param_t* param;

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

  778.             {

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

  780.                 switch ( param->character )

  781.                 {

  782.                     case 'a' :

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

  784.                         break;

  785.                     case 'p':

  786.                         udp_port = param->value.ui;

  787.                         break;

  788.                     case 'M':

  789.                         mtu = param->value.i;

  790.                         break;

  791.                     case 'C':

  792.                         audio_capture_ports = param->value.i;

  793.                         break;

  794.                     case 'P':

  795.                         audio_playback_ports = param->value.i;

  796.                         break;

  797.                     case 'i':

  798.                         midi_input_ports = param->value.i;

  799.                         break;

  800.                     case 'o':

  801.                         midi_output_ports = param->value.i;

  802.                         break;

  803.                     case 'n' :

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

  805.                     case 't' :

  806.                         transport_sync = param->value.ui;

  807.                 }

  808.             }

  809. 

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

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

  812.                                           midi_input_ports, midi_output_ports, name, transport_sync ) );

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

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

  815.                 return driver;

  816. 

  817.             delete driver;

  818.             return NULL;

  819.         }

  820. 

  821. #ifdef __cplusplus

  822.     }

  823. #endif

  824. }