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

826 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 = 4;

  40.     string JackNetDriver::fMonitorFieldNames[] =

  41.     {

  42.         string ( "end of read" ),

  43.         string ( "start of write" ),

  44.         string ( "sync send" ),

  45.         string ( "end of write" )

  46.     };

  47.     uint JackNetDriver::fMonitorPlotOptionsCnt = 2;

  48.     string JackNetDriver::fMonitorPlotOptions[] =

  49.     {

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

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

  52.     };

  53. #endif

  54. 

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

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

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

  58.     {

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

  60. 

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

  62.         strcpy ( fMulticastIP, ip );

  63.         fParams.fMtu = mtu;

  64.         fParams.fSendMidiChannels = midi_input_ports;

  65.         fParams.fReturnMidiChannels = midi_output_ports;

  66.         strcpy ( fParams.fName, net_name );

  67.         fSocket.GetName ( fParams.fSlaveNetName );

  68.         fParams.fTransportSync = transport_sync;

  69. #ifdef JACK_MONITOR

  70.         fMonitor = NULL;

  71.         fMeasure = NULL;

  72. #enfid

  73.     }

  74. 

  75.     JackNetDriver::~JackNetDriver()

  76.     {

  77.         fSocket.Close();

  78.         SocketAPIEnd();

  79.         delete fNetAudioCaptureBuffer;

  80.         delete fNetAudioPlaybackBuffer;

  81.         delete fNetMidiCaptureBuffer;

  82.         delete fNetMidiPlaybackBuffer;

  83.         delete[] fTxBuffer;

  84.         delete[] fRxBuffer;

  85.         delete[] fMulticastIP;

  86.         delete[] fMidiCapturePortList;

  87.         delete[] fMidiPlaybackPortList;

  88. #ifdef JACK_MONITOR

  89.         delete[] fMeasure;

  90.         delete fMonitor;

  91. #endif

  92.     }

  93. 

  94. //*************************************initialization***********************************************************************

  95. 

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

  97.                               int inchannels, int outchannels, bool monitor,

  98.                               const char* capture_driver_name, const char* playback_driver_name,

  99.                               jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  100.     {

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

  102.                                           capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  103.         fEngineControl->fPeriod = 0;

  104.         fEngineControl->fComputation = 500 * 1000;

  105.         fEngineControl->fConstraint = 500 * 1000;

  106.         return res;

  107.     }

  108. 

  109. #ifdef JACK_MONITOR

  110.     int JackNetDriver::Close()

  111.     {

  112.         if ( fMonitor )

  113.             fMonitor->Save();

  114.         return JackDriver::Close();

  115.     }

  116. #endif

  117. 

  118.     int JackNetDriver::Attach()

  119.     {

  120.         return 0;

  121.     }

  122. 

  123.     int JackNetDriver::Detach()

  124.     {

  125.         return 0;

  126.     }

  127. 

  128.     bool JackNetDriver::Init()

  129.     {

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

  131. 

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

  133.         if ( fSocket.IsSocket() )

  134.             Restart();

  135. 

  136.         //set the parameters to send

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

  138.         fParams.fProtocolVersion = 'a';

  139.         SetPacketType ( &fParams, SLAVE_AVAILABLE );

  140.         fParams.fSendAudioChannels = fCaptureChannels;

  141.         fParams.fReturnAudioChannels = fPlaybackChannels;

  142.         fParams.fSlaveSyncMode = fEngineControl->fSyncMode;

  143. 

  144.         //is transport sync ?

  145.         if ( fParams.fTransportSync )

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

  147. 

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

  149.         net_status_t status;

  150.         do

  151.         {

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

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

  154.             do

  155.             {

  156.                 status = GetNetMaster();

  157.                 if ( status == NET_SOCKET_ERROR )

  158.                     return false;

  159.             }

  160.             while ( status != NET_CONNECTED );

  161. 

  162.             //then tell the master we are ready

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

  164.             status = SendMasterStartSync();

  165.             if ( status == NET_ERROR )

  166.                 return false;

  167.         }

  168.         while ( status != NET_ROLLING );

  169. 

  170.         //driver parametering

  171.         if ( SetParams() )

  172.         {

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

  174.             return false;

  175.         }

  176. 

  177.         //init done, display parameters

  178.         SessionParamsDisplay ( &fParams );

  179. 

  180.         return true;

  181.     }

  182. 

  183.     net_status_t JackNetDriver::GetNetMaster()

  184.     {

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

  186.         //utility

  187.         session_params_t params;

  188.         int ms_timeout = 2000;

  189.         int rx_bytes = 0;

  190. 

  191.         //socket

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

  193.         {

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

  195.             return NET_SOCKET_ERROR;

  196.         }

  197. 

  198.         //bind the socket

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

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

  201. 

  202.         //timeout on receive

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

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

  205. 

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

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

  208.         do

  209.         {

  210.             //send 'available'

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

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

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

  214.             do

  215.             {

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

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

  218.                 {

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

  220.                     return NET_RECV_ERROR;

  221.                 }

  222.             }

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

  224.         }

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

  226. 

  227.         //connect the socket

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

  229.         {

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

  231.             return NET_CONNECT_ERROR;

  232.         }

  233. 

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

  235.         fParams = params;

  236. 

  237.         return NET_CONNECTED;

  238.     }

  239. 

  240.     net_status_t JackNetDriver::SendMasterStartSync()

  241.     {

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

  243.         //tell the master to start

  244.         SetPacketType ( &fParams, START_MASTER );

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

  246.         {

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

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

  249.         }

  250.         return NET_ROLLING;

  251.     }

  252. 

  253.     void JackNetDriver::Restart()

  254.     {

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

  256.         delete[] fTxBuffer;

  257.         fTxBuffer = NULL;

  258.         delete[] fRxBuffer;

  259.         fRxBuffer = NULL;

  260.         delete fNetAudioCaptureBuffer;

  261.         fNetAudioCaptureBuffer = NULL;

  262.         delete fNetAudioPlaybackBuffer;

  263.         fNetAudioPlaybackBuffer = NULL;

  264.         delete fNetMidiCaptureBuffer;

  265.         fNetMidiCaptureBuffer = NULL;

  266.         delete fNetMidiPlaybackBuffer;

  267.         fNetMidiPlaybackBuffer = NULL;

  268.         FreePorts();

  269.         delete[] fMidiCapturePortList;

  270.         fMidiCapturePortList = NULL;

  271.         delete[] fMidiPlaybackPortList;

  272.         fMidiPlaybackPortList = NULL;

  273. #ifdef JACK_MONITOR

  274.         delete[] fMeasure;

  275.         fMeasure = NULL;

  276.         delete fMonitor;

  277.         fMonitor = NULL;

  278. #endif

  279.     }

  280. 

  281.     int JackNetDriver::SetParams()

  282.     {

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

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

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

  286. 

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

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

  289. 

  290.         //allocate midi ports lists

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

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

  293. 

  294.         //register jack ports

  295.         if ( AllocPorts() != 0 )

  296.         {

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

  298.             return -1;

  299.         }

  300. 

  301.         //TX header init

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

  303.         fTxHeader.fDataStream = 'r';

  304.         fTxHeader.fID = fParams.fID;

  305.         fTxHeader.fCycle = 1;

  306.         fTxHeader.fSubCycle = 0;

  307.         fTxHeader.fMidiDataSize = 0;

  308.         fTxHeader.fBitdepth = fParams.fBitdepth;

  309. 

  310.         //RX header init

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

  312.         fRxHeader.fDataStream = 's';

  313.         fRxHeader.fID = fParams.fID;

  314.         fRxHeader.fCycle = 0;

  315.         fRxHeader.fSubCycle = 0;

  316.         fRxHeader.fMidiDataSize = 0;

  317.         fRxHeader.fBitdepth = fParams.fBitdepth;

  318. 

  319.         //network buffers

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

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

  322. 

  323.         //net audio/midi buffers

  324.         fTxData = fTxBuffer + sizeof ( packet_header_t );

  325.         fRxData = fRxBuffer + sizeof ( packet_header_t );

  326. 

  327.         //midi net buffers

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

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

  330. 

  331.         //audio net buffers

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

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

  334. 

  335.         //audio netbuffer length

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

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

  338. 

  339.         //payload size

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

  341. 

  342.         //monitor

  343. #ifdef JACK_MONITOR

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

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

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

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

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

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

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

  351. #endif

  352. 

  353.         return 0;

  354.     }

  355. 

  356.     int JackNetDriver::AllocPorts()

  357.     {

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

  359.         JackPort* port;

  360.         jack_port_id_t port_id;

  361.         char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  362.         char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  363.         unsigned long port_flags;

  364.         int audio_port_index;

  365.         uint midi_port_index;

  366. 

  367.         //audio

  368.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  370.         {

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

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

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

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

  375.             {

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

  377.                 return -1;

  378.             }

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

  380.             port->SetAlias ( alias );

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

  382.             fCapturePortList[audio_port_index] = port_id;

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

  384.         }

  385.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  387.         {

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

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

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

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

  392.             {

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

  394.                 return -1;

  395.             }

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

  397.             port->SetAlias ( alias );

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

  399.             fPlaybackPortList[audio_port_index] = port_id;

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

  401.         }

  402.         //midi

  403.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  405.         {

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

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

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

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

  410.             {

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

  412.                 return -1;

  413.             }

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

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

  416.             fMidiCapturePortList[midi_port_index] = port_id;

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

  418.         }

  419. 

  420.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  422.         {

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

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

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

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

  427.             {

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

  429.                 return -1;

  430.             }

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

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

  433.             fMidiPlaybackPortList[midi_port_index] = port_id;

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

  435.         }

  436. 

  437.         return 0;

  438.     }

  439. 

  440.     int JackNetDriver::FreePorts()

  441.     {

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

  443.         int audio_port_index;

  444.         uint midi_port_index;

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

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

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

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

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

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

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

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

  453.         return 0;

  454.     }

  455. 

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

  457.     {

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

  459.     }

  460. 

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

  462.     {

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

  464.     }

  465. 

  466.     int JackNetDriver::SetSyncPacket()

  467.     {

  468.         if ( fParams.fTransportSync )

  469.         {

  470.             //set the TransportData

  471. 

  472.             //copy to TxBuffer

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

  474.         }

  475.         return 0;

  476.     }

  477. 

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

  479.     {

  480.         int rx_bytes;

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

  482.         {

  483.             net_error_t error = fSocket.GetError();

  484.             if ( error == NET_NO_DATA )

  485.             {

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

  487.                 return 0;

  488.             }

  489.             else if ( error == NET_CONN_ERROR )

  490.             {

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

  492.             }

  493.             else

  494.             {

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

  496.                 return 0;

  497.             }

  498.         }

  499.         return rx_bytes;

  500.     }

  501. 

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

  503.     {

  504.         int tx_bytes;

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

  506.         {

  507.             net_error_t error = fSocket.GetError();

  508.             if ( error == NET_CONN_ERROR )

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

  510.             else

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

  512.         }

  513.         return tx_bytes;

  514.     }

  515. 

  516. //*************************************process************************************************************************

  517. 

  518.     int JackNetDriver::Read()

  519.     {

  520.         int rx_bytes;

  521.         uint recvd_midi_pckt = 0;

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

  523.         fRxHeader.fIsLastPckt = 'n';

  524.         uint midi_port_index;

  525.         int audio_port_index;

  526. 

  527.         //buffers

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

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

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

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

  532. 

  533.         //receive sync (launch the cycle)

  534.         do

  535.         {

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

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

  538.                 return rx_bytes;

  539.         }

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

  541. 

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

  543.         JackDriver::CycleTakeBeginTime();

  544. 

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

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

  547.         {

  548.             do

  549.             {

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

  551.                     return rx_bytes;

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

  553.                 {

  554.                     switch ( rx_head->fDataType )

  555.                     {

  556.                         case 'm':   //midi

  557.                             rx_bytes = Recv ( rx_bytes, 0 );

  558.                             fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

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

  561.                                 fNetMidiCaptureBuffer->RenderToJackPorts();

  562.                             break;

  563.                         case 'a':   //audio

  564.                             rx_bytes = Recv ( fAudioRxLen, 0 );

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

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

  567.                             fRxHeader.fCycle = rx_head->fCycle;

  568.                             fRxHeader.fSubCycle = rx_head->fSubCycle;

  569.                             fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

  571.                             break;

  572.                         case 's':   //sync

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

  574.                             fRxHeader.fCycle = rx_head->fCycle;

  575.                             return 0;

  576.                     }

  577.                 }

  578.             }

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

  580.         }

  581.         fRxHeader.fCycle = rx_head->fCycle;

  582. 

  583. 

  584. #ifdef JACK_MONITOR

  585.         fMeasureId = 0;

  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.         uint midi_port_index;

  595.         int tx_bytes, copy_size, audio_port_index;

  596. 

  597.         //tx header

  598.         if ( fEngineControl->fSyncMode )

  599.             fTxHeader.fCycle = fRxHeader.fCycle;

  600.         else

  601.             fTxHeader.fCycle++;

  602.         fTxHeader.fSubCycle = 0;

  603.         fTxHeader.fIsLastPckt = 'n';

  604. 

  605.         //buffers

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

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

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

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

  610. 

  611. #ifdef JACK_MONITOR

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

  613. #endif

  614. 

  615.         //sync

  616.         fTxHeader.fDataType = 's';

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

  618.             fTxHeader.fIsLastPckt = 'y';

  619.         memset ( fTxData, 0, fPayloadSize );

  620.         SetSyncPacket();

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

  622. 

  623. #ifdef JACK_MONITOR

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

  625. #endif

  626. 

  627.         //midi

  628.         if ( fParams.fReturnMidiChannels )

  629.         {

  630.             fTxHeader.fDataType = 'm';

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

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

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

  634.             {

  635.                 fTxHeader.fSubCycle = subproc;

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

  637.                     fTxHeader.fIsLastPckt = 'y';

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

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

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

  641.             }

  642.         }

  643. 

  644.         //audio

  645.         if ( fParams.fReturnAudioChannels )

  646.         {

  647.             fTxHeader.fDataType = 'a';

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

  649.             {

  650.                 fTxHeader.fSubCycle = subproc;

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

  652.                     fTxHeader.fIsLastPckt = 'y';

  653.                 fNetAudioPlaybackBuffer->RenderFromJackPorts ( subproc );

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

  655.                 tx_bytes = Send ( fAudioTxLen, 0 );

  656.             }

  657.         }

  658. 

  659. #ifdef JACK_MONITOR

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

  661.         fMonitor->Write ( fMeasure );

  662. #endif

  663. 

  664.         return 0;

  665.     }

  666. 

  667. //*************************************loader*******************************************************

  668. 

  669. #ifdef __cplusplus

  670.     extern "C"

  671.     {

  672. #endif

  673.         EXPORT jack_driver_desc_t* driver_get_descriptor ()

  674.         {

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

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

  677.             desc->nparams = 9;

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

  679. 

  680.             int i = 0;

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

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

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

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

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

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

  687. 

  688.             i++;

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

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

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

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

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

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

  695. 

  696.             i++;

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

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

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

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

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

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

  703. 

  704.             i++;

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

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

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

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

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

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

  711. 

  712.             i++;

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

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

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

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

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

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

  719. 

  720.             i++;

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

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

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

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

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

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

  727. 

  728.             i++;

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

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

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

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

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

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

  735. 

  736.             i++;

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

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

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

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

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

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

  743. 

  744.             i++;

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

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

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

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

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

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

  751. 

  752.             return desc;

  753.         }

  754. 

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

  756.         {

  757.             if ( SocketAPIInit() < 0 )

  758.             {

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

  760.                 return NULL;

  761.             }

  762.             const char* multicast_ip = DEFAULT_MULTICAST_IP;

  763.             char name[JACK_CLIENT_NAME_SIZE];

  764.             GetHostName ( name, JACK_CLIENT_NAME_SIZE );

  765.             int udp_port = DEFAULT_PORT;

  766.             int mtu = 1500;

  767.             uint transport_sync = 1;

  768.             jack_nframes_t period_size = 128;

  769.             jack_nframes_t sample_rate = 48000;

  770.             int audio_capture_ports = 2;

  771.             int audio_playback_ports = 2;

  772.             int midi_input_ports = 0;

  773.             int midi_output_ports = 0;

  774.             bool monitor = false;

  775. 

  776.             const JSList* node;

  777.             const jack_driver_param_t* param;

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

  779.             {

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

  781.                 switch ( param->character )

  782.                 {

  783.                     case 'a' :

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

  785.                         break;

  786.                     case 'p':

  787.                         udp_port = param->value.ui;

  788.                         break;

  789.                     case 'M':

  790.                         mtu = param->value.i;

  791.                         break;

  792.                     case 'C':

  793.                         audio_capture_ports = param->value.i;

  794.                         break;

  795.                     case 'P':

  796.                         audio_playback_ports = param->value.i;

  797.                         break;

  798.                     case 'i':

  799.                         midi_input_ports = param->value.i;

  800.                         break;

  801.                     case 'o':

  802.                         midi_output_ports = param->value.i;

  803.                         break;

  804.                     case 'n' :

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

  806.                     case 't' :

  807.                         transport_sync = param->value.ui;

  808.                 }

  809.             }

  810. 

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

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

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

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

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

  816.                 return driver;

  817. 

  818.             delete driver;

  819.             return NULL;

  820.         }

  821. 

  822. #ifdef __cplusplus

  823.     }

  824. #endif

  825. }