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

807 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 = 512;

  37.     uint JackNetDriver::fMeasurePoints = 5;

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

  39.     {

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

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

  42.     };

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

  44.     {

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

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

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

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

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

  50.     };

  51. #endif

  52. 

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

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

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

  56.     {

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

  58.         strcpy ( fMulticastIP, ip );

  59.         fParams.fMtu = mtu;

  60.         fParams.fSendMidiChannels = midi_input_ports;

  61.         fParams.fReturnMidiChannels = midi_output_ports;

  62.         strcpy ( fParams.fName, net_name );

  63.         fSocket.GetName ( fParams.fSlaveNetName );

  64.         fParams.fTransportSync = transport_sync;

  65. 

  66.         //monitor

  67. #ifdef JACK_MONITOR

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

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

  70.         fMonitor.SetPlotFile ( plot_file_name, JackNetDriver::fMonitorPlotOptions, 2, JackNetDriver::fMonitorFieldNames, 5 );

  71. #endif

  72.     }

  73. 

  74.     JackNetDriver::~JackNetDriver()

  75.     {

  76.         fSocket.Close();

  77.         SocketAPIEnd();

  78.         delete fNetAudioCaptureBuffer;

  79.         delete fNetAudioPlaybackBuffer;

  80.         delete fNetMidiCaptureBuffer;

  81.         delete fNetMidiPlaybackBuffer;

  82.         delete[] fTxBuffer;

  83.         delete[] fRxBuffer;

  84.         delete[] fMulticastIP;

  85.         delete[] fMidiCapturePortList;

  86.         delete[] fMidiPlaybackPortList;

  87. #ifdef JACK_MONITOR

  88. 		delete[] fMeasure;

  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. 

  108. #ifdef JACK_MONITOR

  109.     int JackNetDriver::Close()

  110.     {

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

  112.         fMonitor.Save ( filename );

  113.         return JackDriver::Close();

  114.     }

  115. #endif

  116. 

  117.     int JackNetDriver::Attach()

  118.     {

  119.         return 0;

  120.     }

  121. 

  122.     int JackNetDriver::Detach()

  123.     {

  124.         return 0;

  125.     }

  126. 

  127.     bool JackNetDriver::Init()

  128.     {

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

  130. 

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

  132.         if ( fSocket.IsSocket() )

  133.             Restart();

  134. 

  135.         //set the parameters to send

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

  137.         fParams.fProtocolVersion = 'a';

  138.         SetPacketType ( &fParams, SLAVE_AVAILABLE );

  139.         fParams.fSendAudioChannels = fCaptureChannels;

  140.         fParams.fReturnAudioChannels = fPlaybackChannels;

  141. 

  142.         //is transport sync ?

  143.         if ( fParams.fTransportSync )

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

  145. 

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

  147.         net_status_t status;

  148.         do

  149.         {

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

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

  152.             do

  153.             {

  154.                 status = GetNetMaster();

  155.                 if ( status == NET_SOCKET_ERROR )

  156.                     return false;

  157.             }

  158.             while ( status != NET_CONNECTED );

  159. 

  160.             //then tell the master we are ready

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

  162.             status = SendMasterStartSync();

  163.             if ( status == NET_ERROR )

  164.                 return false;

  165.         }

  166.         while ( status != NET_ROLLING );

  167. 

  168.         //driver parametering

  169.         if ( SetParams() )

  170.         {

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

  172.             return false;

  173.         }

  174. 

  175.         //init done, display parameters

  176.         SessionParamsDisplay ( &fParams );

  177. 

  178.         return true;

  179.     }

  180. 

  181.     net_status_t JackNetDriver::GetNetMaster()

  182.     {

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

  184.         //utility

  185.         session_params_t params;

  186.         int ms_timeout = 2000;

  187.         int rx_bytes = 0;

  188. 

  189.         //socket

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

  191.         {

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

  193.             return NET_SOCKET_ERROR;

  194.         }

  195. 

  196.         //bind the socket

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

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

  199. 

  200.         //timeout on receive

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

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

  203. 

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

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

  206.         do

  207.         {

  208.             //send 'available'

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

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

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

  212.             do

  213.             {

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

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

  216.                 {

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

  218.                     return NET_RECV_ERROR;

  219.                 }

  220.             }

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

  222.         }

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

  224. 

  225.         //connect the socket

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

  227.         {

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

  229.             return NET_CONNECT_ERROR;

  230.         }

  231. 

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

  233.         fParams = params;

  234. 

  235.         return NET_CONNECTED;

  236.     }

  237. 

  238.     net_status_t JackNetDriver::SendMasterStartSync()

  239.     {

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

  241.         //tell the master to start

  242.         SetPacketType ( &fParams, START_MASTER );

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

  244.         {

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

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

  247.         }

  248.         return NET_ROLLING;

  249.     }

  250. 

  251.     void JackNetDriver::Restart()

  252.     {

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

  254.         delete[] fTxBuffer;

  255.         delete[] fRxBuffer;

  256.         delete fNetAudioCaptureBuffer;

  257.         delete fNetAudioPlaybackBuffer;

  258.         delete fNetMidiCaptureBuffer;

  259.         delete fNetMidiPlaybackBuffer;

  260.         FreePorts();

  261.         delete[] fMidiCapturePortList;

  262.         delete[] fMidiPlaybackPortList;

  263.         fTxBuffer = NULL;

  264.         fRxBuffer = NULL;

  265.         fNetAudioCaptureBuffer = NULL;

  266.         fNetAudioPlaybackBuffer = NULL;

  267.         fNetMidiCaptureBuffer = NULL;

  268.         fNetMidiPlaybackBuffer = NULL;

  269.         fMidiCapturePortList = NULL;

  270.         fMidiPlaybackPortList = NULL;

  271.     }

  272. 

  273.     int JackNetDriver::SetParams()

  274.     {

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

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

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

  278. 

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

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

  281. 

  282.         //allocate midi ports lists

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

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

  285. 

  286.         //register jack ports

  287.         if ( AllocPorts() != 0 )

  288.         {

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

  290.             return -1;

  291.         }

  292. 

  293.         //TX header init

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

  295.         fTxHeader.fDataStream = 'r';

  296.         fTxHeader.fID = fParams.fID;

  297.         fTxHeader.fCycle = 0;

  298.         fTxHeader.fSubCycle = 0;

  299.         fTxHeader.fMidiDataSize = 0;

  300.         fTxHeader.fBitdepth = fParams.fBitdepth;

  301. 

  302.         //RX header init

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

  304.         fRxHeader.fDataStream = 's';

  305.         fRxHeader.fID = fParams.fID;

  306.         fRxHeader.fCycle = 0;

  307.         fRxHeader.fSubCycle = 0;

  308.         fRxHeader.fMidiDataSize = 0;

  309.         fRxHeader.fBitdepth = fParams.fBitdepth;

  310. 

  311.         //network buffers

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

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

  314. 

  315.         //net audio/midi buffers

  316.         fTxData = fTxBuffer + sizeof ( packet_header_t );

  317.         fRxData = fRxBuffer + sizeof ( packet_header_t );

  318. 

  319.         //midi net buffers

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

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

  322. 

  323.         //audio net buffers

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

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

  326. 

  327.         //audio netbuffer length

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

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

  330. 

  331.         //payload size

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

  333. 

  334.         return 0;

  335.     }

  336. 

  337.     int JackNetDriver::AllocPorts()

  338.     {

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

  340.         JackPort* port;

  341.         jack_port_id_t port_id;

  342.         char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  343.         char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  344.         unsigned long port_flags;

  345.         int audio_port_index;

  346.         uint midi_port_index;

  347. 

  348.         //audio

  349.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  351.         {

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

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

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

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

  356.             {

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

  358.                 return -1;

  359.             }

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

  361.             port->SetAlias ( alias );

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

  363.             fCapturePortList[audio_port_index] = port_id;

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

  365.         }

  366.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  368.         {

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

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

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

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

  373.             {

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

  375.                 return -1;

  376.             }

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

  378.             port->SetAlias ( alias );

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

  380.             fPlaybackPortList[audio_port_index] = port_id;

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

  382.         }

  383.         //midi

  384.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  386.         {

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

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

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

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

  391.             {

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

  393.                 return -1;

  394.             }

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

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

  397.             fMidiCapturePortList[midi_port_index] = port_id;

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

  399.         }

  400. 

  401.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  403.         {

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

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

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

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

  408.             {

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

  410.                 return -1;

  411.             }

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

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

  414.             fMidiPlaybackPortList[midi_port_index] = port_id;

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

  416.         }

  417. 

  418.         return 0;

  419.     }

  420. 

  421.     int JackNetDriver::FreePorts()

  422.     {

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

  424.         int audio_port_index;

  425.         uint midi_port_index;

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

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

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

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

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

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

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

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

  434.         return 0;

  435.     }

  436. 

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

  438.     {

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

  440.     }

  441. 

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

  443.     {

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

  445.     }

  446. 

  447.     int JackNetDriver::SetSyncPacket()

  448.     {

  449.         if ( fParams.fTransportSync )

  450.         {

  451.             //set the TransportData

  452. 

  453.             //copy to TxBuffer

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

  455.         }

  456.         return 0;

  457.     }

  458. 

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

  460.     {

  461.         int rx_bytes;

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

  463.         {

  464.             net_error_t error = fSocket.GetError();

  465.             if ( error == NET_NO_DATA )

  466.             {

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

  468.                 return 0;

  469.             }

  470.             else if ( error == NET_CONN_ERROR )

  471.             {

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

  473.             }

  474.             else

  475.             {

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

  477.                 return 0;

  478.             }

  479.         }

  480.         return rx_bytes;

  481.     }

  482. 

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

  484.     {

  485.         int tx_bytes;

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

  487.         {

  488.             net_error_t error = fSocket.GetError();

  489.             if ( error == NET_CONN_ERROR )

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

  491.             else

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

  493.         }

  494.         return tx_bytes;

  495.     }

  496. 

  497. //*************************************process************************************************************************

  498. 

  499.     int JackNetDriver::Read()

  500.     {

  501.         int rx_bytes;

  502.         uint recvd_midi_pckt = 0;

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

  504.         fRxHeader.fIsLastPckt = 'n';

  505.         uint midi_port_index;

  506.         int audio_port_index;

  507. 

  508.         //buffers

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

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

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

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

  513. 

  514.         //receive sync (launch the cycle)

  515.         do

  516.         {

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

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

  519.                 return rx_bytes;

  520.         }

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

  522. 

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

  524.         JackDriver::CycleTakeBeginTime();

  525. 

  526. #ifdef JACK_MONITOR

  527.         fUsecCycleStart = GetMicroSeconds();

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

  529. #endif

  530. 

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

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

  533.         {

  534.             do

  535.             {

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

  537.                     return rx_bytes;

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

  539.                 {

  540.                     switch ( rx_head->fDataType )

  541.                     {

  542.                     case 'm':	//midi

  543.                         rx_bytes = Recv ( rx_bytes, 0 );

  544.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

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

  547.                             fNetMidiCaptureBuffer->RenderToJackPorts();

  548.                         break;

  549.                     case 'a':	//audio

  550.                         rx_bytes = Recv ( fAudioRxLen, 0 );

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

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

  553.                         fRxHeader.fCycle = rx_head->fCycle;

  554.                         fRxHeader.fSubCycle = rx_head->fSubCycle;

  555.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

  557.                         break;

  558.                     case 's':	//sync

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

  560.                         fRxHeader.fCycle = rx_head->fCycle;

  561.                         return 0;

  562.                     }

  563.                 }

  564.             }

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

  566.         }

  567.         fRxHeader.fCycle = rx_head->fCycle;

  568. 

  569. 

  570. #ifdef JACK_MONITOR

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

  572. #endif

  573. 

  574.         return 0;

  575.     }

  576. 

  577.     int JackNetDriver::Write()

  578.     {

  579.         int tx_bytes, copy_size;

  580.         fTxHeader.fCycle = fRxHeader.fCycle;

  581.         fTxHeader.fSubCycle = 0;

  582.         fTxHeader.fIsLastPckt = 'n';

  583.         uint midi_port_index;

  584.         int audio_port_index;

  585. 

  586.         //buffers

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

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

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

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

  591. 

  592. #ifdef JACK_MONITOR

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

  594. #endif

  595. 

  596.         //sync

  597.         fTxHeader.fDataType = 's';

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

  599.             fTxHeader.fIsLastPckt = 'y';

  600.         memset ( fTxData, 0, fPayloadSize );

  601.         SetSyncPacket();

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

  603. 

  604. #ifdef JACK_MONITOR

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

  606. #endif

  607. 

  608.         //midi

  609.         if ( fParams.fReturnMidiChannels )

  610.         {

  611.             fTxHeader.fDataType = 'm';

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

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

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

  615.             {

  616.                 fTxHeader.fSubCycle = subproc;

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

  618.                     fTxHeader.fIsLastPckt = 'y';

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

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

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

  622.             }

  623.         }

  624. 

  625.         //audio

  626.         if ( fParams.fReturnAudioChannels )

  627.         {

  628.             fTxHeader.fDataType = 'a';

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

  630.             {

  631.                 fTxHeader.fSubCycle = subproc;

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

  633.                     fTxHeader.fIsLastPckt = 'y';

  634.                 fNetAudioPlaybackBuffer->RenderFromJackPorts ( subproc );

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

  636.                 tx_bytes = Send ( fAudioTxLen, 0 );

  637.             }

  638.         }

  639. 

  640. #ifdef JACK_MONITOR

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

  642.         fMonitor.Write ( fMeasure );

  643. #endif

  644. 

  645.         return 0;

  646.     }

  647. 

  648. //*************************************loader*******************************************************

  649. 

  650. #ifdef __cplusplus

  651.     extern "C"

  652.     {

  653. #endif

  654.         EXPORT jack_driver_desc_t* driver_get_descriptor ()

  655.         {

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

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

  658.             desc->nparams = 9;

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

  660. 

  661.             int i = 0;

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

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

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

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

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

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

  668. 

  669.             i++;

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

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

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

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

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

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

  676. 

  677.             i++;

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

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

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

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

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

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

  684. 

  685.             i++;

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

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

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

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

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

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

  692. 

  693.             i++;

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

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

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

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

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

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

  700. 

  701.             i++;

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

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

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

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

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

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

  708. 

  709.             i++;

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

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

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

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

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

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

  716. 

  717.             i++;

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

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

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

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

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

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

  724. 

  725.             i++;

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

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

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

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

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

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

  732. 

  733.             return desc;

  734.         }

  735. 

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

  737.         {

  738.             if ( SocketAPIInit() < 0 )

  739.             {

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

  741.                 return NULL;

  742.             }

  743.             const char* multicast_ip = DEFAULT_MULTICAST_IP;

  744.             char name[JACK_CLIENT_NAME_SIZE];

  745.             GetHostName ( name, JACK_CLIENT_NAME_SIZE );

  746.             int udp_port = DEFAULT_PORT;

  747.             int mtu = 1500;

  748.             uint transport_sync = 1;

  749.             jack_nframes_t period_size = 128;

  750.             jack_nframes_t sample_rate = 48000;

  751.             int audio_capture_ports = 2;

  752.             int audio_playback_ports = 2;

  753.             int midi_input_ports = 0;

  754.             int midi_output_ports = 0;

  755.             bool monitor = false;

  756. 

  757.             const JSList* node;

  758.             const jack_driver_param_t* param;

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

  760.             {

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

  762.                 switch ( param->character )

  763.                 {

  764.                 case 'a' :

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

  766.                     break;

  767.                 case 'p':

  768.                     udp_port = param->value.ui;

  769.                     break;

  770.                 case 'M':

  771.                     mtu = param->value.i;

  772.                     break;

  773.                 case 'C':

  774.                     audio_capture_ports = param->value.i;

  775.                     break;

  776.                 case 'P':

  777.                     audio_playback_ports = param->value.i;

  778.                     break;

  779.                 case 'i':

  780.                     midi_input_ports = param->value.i;

  781.                     break;

  782.                 case 'o':

  783.                     midi_output_ports = param->value.i;

  784.                     break;

  785.                 case 'n' :

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

  787.                 case 't' :

  788.                     transport_sync = param->value.ui;

  789.                 }

  790.             }

  791. 

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

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

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

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

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

  797.                 return driver;

  798. 

  799.             delete driver;

  800.             return NULL;

  801.         }

  802. 

  803. #ifdef __cplusplus

  804.     }

  805. #endif

  806. }