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

811 lines
32KB
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. namespace Jack

  34. {

  35. #ifdef JACK_MONITOR

  36.     uint JackNetDriver::fMeasureCnt = 50;

  37.     uint JackNetDriver::fMeasurePoints = 5;

  38.     uint JackNetDriver::fMonitorPlotOptionsCnt = 2;

  39.     std::string JackNetDriver::fMonitorPlotOptions[] =

  40.     {

  41.         std::string ( "set xlabel \"audio cycles\"" ),

  42.         std::string ( "set ylabel \"usecs\"" )

  43.     };

  44.     std::string JackNetDriver::fMonitorFieldNames[] =

  45.     {

  46.         std::string ( "cyclestart" ),

  47.         std::string ( "read end" ),

  48.         std::string ( "write start" ),

  49.         std::string ( "sync end" ),

  50.         std::string ( "send end" )

  51.     };

  52. #endif

  53. 

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

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

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

  57.     {

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

  59.         strcpy ( fMulticastIP, ip );

  60.         fParams.fMtu = mtu;

  61.         fParams.fSendMidiChannels = midi_input_ports;

  62.         fParams.fReturnMidiChannels = midi_output_ports;

  63.         strcpy ( fParams.fName, net_name );

  64.         fSocket.GetName ( fParams.fSlaveNetName );

  65.         fParams.fTransportSync = transport_sync;

  66. 

  67.         //monitor

  68. #ifdef JACK_MONITOR

  69. 		fMonitor = new NetMonitor<jack_time_t> ( JackNetDriver::fMeasureCnt, JackNetDriver::fMeasurePoints );

  70.         fMeasure = new jack_time_t[JackNetDriver::fMeasurePoints];

  71.         std::string plot_file_name = std::string ( fParams.fName );

  72.         fMonitor->SetPlotFile ( plot_file_name, JackNetDriver::fMonitorPlotOptions, JackNetDriver::fMonitorPlotOptionsCnt,

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

  74. #endif

  75.     }

  76. 

  77.     JackNetDriver::~JackNetDriver()

  78.     {

  79.         fSocket.Close();

  80.         SocketAPIEnd();

  81.         delete fNetAudioCaptureBuffer;

  82.         delete fNetAudioPlaybackBuffer;

  83.         delete fNetMidiCaptureBuffer;

  84.         delete fNetMidiPlaybackBuffer;

  85.         delete[] fTxBuffer;

  86.         delete[] fRxBuffer;

  87.         delete[] fMulticastIP;

  88.         delete[] fMidiCapturePortList;

  89.         delete[] fMidiPlaybackPortList;

  90. #ifdef JACK_MONITOR

  91. 		delete[] fMeasure;

  92. 		delete fMonitor;

  93. #endif

  94.     }

  95. 

  96. //*************************************initialization***********************************************************************

  97. 

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

  99.                               int inchannels, int outchannels, bool monitor,

  100.                               const char* capture_driver_name, const char* playback_driver_name,

  101.                               jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  102.     {

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

  104.                                           capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  105.         fEngineControl->fPeriod = 0;

  106.         fEngineControl->fComputation = 500 * 1000;

  107.         fEngineControl->fConstraint = 500 * 1000;

  108.         return res;

  109.     }

  110. 

  111. 

  112. #ifdef JACK_MONITOR

  113.     int JackNetDriver::Close()

  114.     {

  115.         std::string filename = string ( fParams.fName );

  116.         fMonitor->Save ( filename );

  117.         return JackDriver::Close();

  118.     }

  119. #endif

  120. 

  121.     int JackNetDriver::Attach()

  122.     {

  123.         return 0;

  124.     }

  125. 

  126.     int JackNetDriver::Detach()

  127.     {

  128.         return 0;

  129.     }

  130. 

  131.     bool JackNetDriver::Init()

  132.     {

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

  134. 

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

  136.         if ( fSocket.IsSocket() )

  137.             Restart();

  138. 

  139.         //set the parameters to send

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

  141.         fParams.fProtocolVersion = 'a';

  142.         SetPacketType ( &fParams, SLAVE_AVAILABLE );

  143.         fParams.fSendAudioChannels = fCaptureChannels;

  144.         fParams.fReturnAudioChannels = fPlaybackChannels;

  145. 

  146.         //is transport sync ?

  147.         if ( fParams.fTransportSync )

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

  149. 

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

  151.         net_status_t status;

  152.         do

  153.         {

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

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

  156.             do

  157.             {

  158.                 status = GetNetMaster();

  159.                 if ( status == NET_SOCKET_ERROR )

  160.                     return false;

  161.             }

  162.             while ( status != NET_CONNECTED );

  163. 

  164.             //then tell the master we are ready

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

  166.             status = SendMasterStartSync();

  167.             if ( status == NET_ERROR )

  168.                 return false;

  169.         }

  170.         while ( status != NET_ROLLING );

  171. 

  172.         //driver parametering

  173.         if ( SetParams() )

  174.         {

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

  176.             return false;

  177.         }

  178. 

  179.         //init done, display parameters

  180.         SessionParamsDisplay ( &fParams );

  181. 

  182.         return true;

  183.     }

  184. 

  185.     net_status_t JackNetDriver::GetNetMaster()

  186.     {

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

  188.         //utility

  189.         session_params_t params;

  190.         int ms_timeout = 2000;

  191.         int rx_bytes = 0;

  192. 

  193.         //socket

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

  195.         {

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

  197.             return NET_SOCKET_ERROR;

  198.         }

  199. 

  200.         //bind the socket

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

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

  203. 

  204.         //timeout on receive

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

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

  207. 

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

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

  210.         do

  211.         {

  212.             //send 'available'

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

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

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

  216.             do

  217.             {

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

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

  220.                 {

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

  222.                     return NET_RECV_ERROR;

  223.                 }

  224.             }

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

  226.         }

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

  228. 

  229.         //connect the socket

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

  231.         {

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

  233.             return NET_CONNECT_ERROR;

  234.         }

  235. 

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

  237.         fParams = params;

  238. 

  239.         return NET_CONNECTED;

  240.     }

  241. 

  242.     net_status_t JackNetDriver::SendMasterStartSync()

  243.     {

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

  245.         //tell the master to start

  246.         SetPacketType ( &fParams, START_MASTER );

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

  248.         {

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

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

  251.         }

  252.         return NET_ROLLING;

  253.     }

  254. 

  255.     void JackNetDriver::Restart()

  256.     {

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

  258.         delete[] fTxBuffer;

  259.         delete[] fRxBuffer;

  260.         delete fNetAudioCaptureBuffer;

  261.         delete fNetAudioPlaybackBuffer;

  262.         delete fNetMidiCaptureBuffer;

  263.         delete fNetMidiPlaybackBuffer;

  264.         FreePorts();

  265.         delete[] fMidiCapturePortList;

  266.         delete[] fMidiPlaybackPortList;

  267.         fTxBuffer = NULL;

  268.         fRxBuffer = NULL;

  269.         fNetAudioCaptureBuffer = NULL;

  270.         fNetAudioPlaybackBuffer = NULL;

  271.         fNetMidiCaptureBuffer = NULL;

  272.         fNetMidiPlaybackBuffer = NULL;

  273.         fMidiCapturePortList = NULL;

  274.         fMidiPlaybackPortList = NULL;

  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.         return 0;

  339.     }

  340. 

  341.     int JackNetDriver::AllocPorts()

  342.     {

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

  344.         JackPort* port;

  345.         jack_port_id_t port_id;

  346.         char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  347.         char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  348.         unsigned long port_flags;

  349.         int audio_port_index;

  350.         uint midi_port_index;

  351. 

  352.         //audio

  353.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  355.         {

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

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

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

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

  360.             {

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

  362.                 return -1;

  363.             }

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

  365.             port->SetAlias ( alias );

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

  367.             fCapturePortList[audio_port_index] = port_id;

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

  369.         }

  370.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  372.         {

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

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

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

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

  377.             {

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

  379.                 return -1;

  380.             }

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

  382.             port->SetAlias ( alias );

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

  384.             fPlaybackPortList[audio_port_index] = port_id;

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

  386.         }

  387.         //midi

  388.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  390.         {

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

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

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

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

  395.             {

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

  397.                 return -1;

  398.             }

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

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

  401.             fMidiCapturePortList[midi_port_index] = port_id;

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

  403.         }

  404. 

  405.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  407.         {

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

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

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

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

  412.             {

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

  414.                 return -1;

  415.             }

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

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

  418.             fMidiPlaybackPortList[midi_port_index] = port_id;

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

  420.         }

  421. 

  422.         return 0;

  423.     }

  424. 

  425.     int JackNetDriver::FreePorts()

  426.     {

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

  428.         int audio_port_index;

  429.         uint midi_port_index;

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

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

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

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

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

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

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

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

  438.         return 0;

  439.     }

  440. 

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

  442.     {

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

  444.     }

  445. 

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

  447.     {

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

  449.     }

  450. 

  451.     int JackNetDriver::SetSyncPacket()

  452.     {

  453.         if ( fParams.fTransportSync )

  454.         {

  455.             //set the TransportData

  456. 

  457.             //copy to TxBuffer

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

  459.         }

  460.         return 0;

  461.     }

  462. 

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

  464.     {

  465.         int rx_bytes;

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

  467.         {

  468.             net_error_t error = fSocket.GetError();

  469.             if ( error == NET_NO_DATA )

  470.             {

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

  472.                 return 0;

  473.             }

  474.             else if ( error == NET_CONN_ERROR )

  475.             {

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

  477.             }

  478.             else

  479.             {

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

  481.                 return 0;

  482.             }

  483.         }

  484.         return rx_bytes;

  485.     }

  486. 

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

  488.     {

  489.         int tx_bytes;

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

  491.         {

  492.             net_error_t error = fSocket.GetError();

  493.             if ( error == NET_CONN_ERROR )

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

  495.             else

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

  497.         }

  498.         return tx_bytes;

  499.     }

  500. 

  501. //*************************************process************************************************************************

  502. 

  503.     int JackNetDriver::Read()

  504.     {

  505.         int rx_bytes;

  506.         uint recvd_midi_pckt = 0;

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

  508.         fRxHeader.fIsLastPckt = 'n';

  509.         uint midi_port_index;

  510.         int audio_port_index;

  511. 

  512.         //buffers

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

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

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

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

  517. 

  518.         //receive sync (launch the cycle)

  519.         do

  520.         {

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

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

  523.                 return rx_bytes;

  524.         }

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

  526. 

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

  528.         JackDriver::CycleTakeBeginTime();

  529. 

  530. #ifdef JACK_MONITOR

  531.         fUsecCycleStart = GetMicroSeconds();

  532.         fMeasure[0] = GetMicroSeconds() - fUsecCycleStart;

  533. #endif

  534. 

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

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

  537.         {

  538.             do

  539.             {

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

  541.                     return rx_bytes;

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

  543.                 {

  544.                     switch ( rx_head->fDataType )

  545.                     {

  546.                     case 'm':	//midi

  547.                         rx_bytes = Recv ( rx_bytes, 0 );

  548.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

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

  551.                             fNetMidiCaptureBuffer->RenderToJackPorts();

  552.                         break;

  553.                     case 'a':	//audio

  554.                         rx_bytes = Recv ( fAudioRxLen, 0 );

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

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

  557.                         fRxHeader.fCycle = rx_head->fCycle;

  558.                         fRxHeader.fSubCycle = rx_head->fSubCycle;

  559.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

  561.                         break;

  562.                     case 's':	//sync

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

  564.                         fRxHeader.fCycle = rx_head->fCycle;

  565.                         return 0;

  566.                     }

  567.                 }

  568.             }

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

  570.         }

  571.         fRxHeader.fCycle = rx_head->fCycle;

  572. 

  573. 

  574. #ifdef JACK_MONITOR

  575.         fMeasure[1] = GetMicroSeconds() - fUsecCycleStart;

  576. #endif

  577. 

  578.         return 0;

  579.     }

  580. 

  581.     int JackNetDriver::Write()

  582.     {

  583.         int tx_bytes, copy_size;

  584.         fTxHeader.fCycle = fRxHeader.fCycle;

  585.         fTxHeader.fSubCycle = 0;

  586.         fTxHeader.fIsLastPckt = 'n';

  587.         uint midi_port_index;

  588.         int audio_port_index;

  589. 

  590.         //buffers

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

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

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

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

  595. 

  596. #ifdef JACK_MONITOR

  597.         fMeasure[2] = GetMicroSeconds() - fUsecCycleStart;

  598. #endif

  599. 

  600.         //sync

  601.         fTxHeader.fDataType = 's';

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

  603.             fTxHeader.fIsLastPckt = 'y';

  604.         memset ( fTxData, 0, fPayloadSize );

  605.         SetSyncPacket();

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

  607. 

  608. #ifdef JACK_MONITOR

  609.         fMeasure[3] = GetMicroSeconds() - fUsecCycleStart;

  610. #endif

  611. 

  612.         //midi

  613.         if ( fParams.fReturnMidiChannels )

  614.         {

  615.             fTxHeader.fDataType = 'm';

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

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

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

  619.             {

  620.                 fTxHeader.fSubCycle = subproc;

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

  622.                     fTxHeader.fIsLastPckt = 'y';

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

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

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

  626.             }

  627.         }

  628. 

  629.         //audio

  630.         if ( fParams.fReturnAudioChannels )

  631.         {

  632.             fTxHeader.fDataType = 'a';

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

  634.             {

  635.                 fTxHeader.fSubCycle = subproc;

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

  637.                     fTxHeader.fIsLastPckt = 'y';

  638.                 fNetAudioPlaybackBuffer->RenderFromJackPorts ( subproc );

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

  640.                 tx_bytes = Send ( fAudioTxLen, 0 );

  641.             }

  642.         }

  643. 

  644. #ifdef JACK_MONITOR

  645.         fMeasure[4] = GetMicroSeconds() - fUsecCycleStart;

  646.         fMonitor->Write ( fMeasure );

  647. #endif

  648. 

  649.         return 0;

  650.     }

  651. 

  652. //*************************************loader*******************************************************

  653. 

  654. #ifdef __cplusplus

  655.     extern "C"

  656.     {

  657. #endif

  658.         EXPORT jack_driver_desc_t* driver_get_descriptor ()

  659.         {

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

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

  662.             desc->nparams = 9;

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

  664. 

  665.             int i = 0;

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

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

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

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

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

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

  672. 

  673.             i++;

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

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

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

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

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

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

  680. 

  681.             i++;

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

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

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

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

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

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

  688. 

  689.             i++;

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

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

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

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

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

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

  696. 

  697.             i++;

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

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

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

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

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

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

  704. 

  705.             i++;

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

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

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

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

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

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

  712. 

  713.             i++;

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

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

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

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

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

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

  720. 

  721.             i++;

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

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

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

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

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

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

  728. 

  729.             i++;

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

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

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

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

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

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

  736. 

  737.             return desc;

  738.         }

  739. 

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

  741.         {

  742.             if ( SocketAPIInit() < 0 )

  743.             {

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

  745.                 return NULL;

  746.             }

  747.             const char* multicast_ip = DEFAULT_MULTICAST_IP;

  748.             char name[JACK_CLIENT_NAME_SIZE];

  749.             GetHostName ( name, JACK_CLIENT_NAME_SIZE );

  750.             int udp_port = DEFAULT_PORT;

  751.             int mtu = 1500;

  752.             uint transport_sync = 1;

  753.             jack_nframes_t period_size = 128;

  754.             jack_nframes_t sample_rate = 48000;

  755.             int audio_capture_ports = 2;

  756.             int audio_playback_ports = 2;

  757.             int midi_input_ports = 0;

  758.             int midi_output_ports = 0;

  759.             bool monitor = false;

  760. 

  761.             const JSList* node;

  762.             const jack_driver_param_t* param;

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

  764.             {

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

  766.                 switch ( param->character )

  767.                 {

  768.                 case 'a' :

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

  770.                     break;

  771.                 case 'p':

  772.                     udp_port = param->value.ui;

  773.                     break;

  774.                 case 'M':

  775.                     mtu = param->value.i;

  776.                     break;

  777.                 case 'C':

  778.                     audio_capture_ports = param->value.i;

  779.                     break;

  780.                 case 'P':

  781.                     audio_playback_ports = param->value.i;

  782.                     break;

  783.                 case 'i':

  784.                     midi_input_ports = param->value.i;

  785.                     break;

  786.                 case 'o':

  787.                     midi_output_ports = param->value.i;

  788.                     break;

  789.                 case 'n' :

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

  791.                 case 't' :

  792.                     transport_sync = param->value.ui;

  793.                 }

  794.             }

  795. 

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

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

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

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

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

  801.                 return driver;

  802. 

  803.             delete driver;

  804.             return NULL;

  805.         }

  806. 

  807. #ifdef __cplusplus

  808.     }

  809. #endif

  810. }