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

801 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.     std::string JackNetDriver::fMonitorPlotOptions[] =

  37.     {

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

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

  40.     };

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

  42.     {

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

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

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

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

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

  48.     };

  49. #endif

  50. 

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

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

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

  54.     {

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

  56.         strcpy ( fMulticastIP, ip );

  57.         fParams.fMtu = mtu;

  58.         fParams.fSendMidiChannels = midi_input_ports;

  59.         fParams.fReturnMidiChannels = midi_output_ports;

  60.         strcpy ( fParams.fName, net_name );

  61.         fSocket.GetName ( fParams.fSlaveNetName );

  62.         fParams.fTransportSync = transport_sync;

  63. 

  64.         //monitor

  65. #ifdef JACK_MONITOR

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

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

  68. #endif

  69.     }

  70. 

  71.     JackNetDriver::~JackNetDriver()

  72.     {

  73.         fSocket.Close();

  74.         SocketAPIEnd();

  75.         delete fNetAudioCaptureBuffer;

  76.         delete fNetAudioPlaybackBuffer;

  77.         delete fNetMidiCaptureBuffer;

  78.         delete fNetMidiPlaybackBuffer;

  79.         delete[] fTxBuffer;

  80.         delete[] fRxBuffer;

  81.         delete[] fMulticastIP;

  82.         delete[] fMidiCapturePortList;

  83.         delete[] fMidiPlaybackPortList;

  84.     }

  85. 

  86. //*************************************initialization***********************************************************************

  87. 

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

  89.                               int inchannels, int outchannels, bool monitor,

  90.                               const char* capture_driver_name, const char* playback_driver_name,

  91.                               jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  92.     {

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

  94.                                           capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  95.         fEngineControl->fPeriod = 0;

  96.         fEngineControl->fComputation = 500 * 1000;

  97.         fEngineControl->fConstraint = 500 * 1000;

  98.         return res;

  99.     }

  100. 

  101. 

  102. #ifdef JACK_MONITOR

  103.     int JackNetDriver::Close()

  104.     {

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

  106.         fMonitor.Save ( filename );

  107.         return JackDriver::Close();

  108.     }

  109. #endif

  110. 

  111.     int JackNetDriver::Attach()

  112.     {

  113.         return 0;

  114.     }

  115. 

  116.     int JackNetDriver::Detach()

  117.     {

  118.         return 0;

  119.     }

  120. 

  121.     bool JackNetDriver::Init()

  122.     {

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

  124. 

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

  126.         if ( fSocket.IsSocket() )

  127.             Restart();

  128. 

  129.         //set the parameters to send

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

  131.         fParams.fProtocolVersion = 'a';

  132.         SetPacketType ( &fParams, SLAVE_AVAILABLE );

  133.         fParams.fSendAudioChannels = fCaptureChannels;

  134.         fParams.fReturnAudioChannels = fPlaybackChannels;

  135. 

  136.         //is transport sync ?

  137.         if ( fParams.fTransportSync )

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

  139. 

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

  141.         net_status_t status;

  142.         do

  143.         {

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

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

  146.             do

  147.             {

  148.                 status = GetNetMaster();

  149.                 if ( status == NET_SOCKET_ERROR )

  150.                     return false;

  151.             }

  152.             while ( status != NET_CONNECTED );

  153. 

  154.             //then tell the master we are ready

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

  156.             status = SendMasterStartSync();

  157.             if ( status == NET_ERROR )

  158.                 return false;

  159.         }

  160.         while ( status != NET_ROLLING );

  161. 

  162.         //driver parametering

  163.         if ( SetParams() )

  164.         {

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

  166.             return false;

  167.         }

  168. 

  169.         //init done, display parameters

  170.         SessionParamsDisplay ( &fParams );

  171. 

  172.         return true;

  173.     }

  174. 

  175.     net_status_t JackNetDriver::GetNetMaster()

  176.     {

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

  178.         //utility

  179.         session_params_t params;

  180.         int ms_timeout = 2000;

  181.         int rx_bytes = 0;

  182. 

  183.         //socket

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

  185.         {

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

  187.             return NET_SOCKET_ERROR;

  188.         }

  189. 

  190.         //bind the socket

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

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

  193. 

  194.         //timeout on receive

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

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

  197. 

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

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

  200.         do

  201.         {

  202.             //send 'available'

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

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

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

  206.             do

  207.             {

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

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

  210.                 {

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

  212.                     return NET_RECV_ERROR;

  213.                 }

  214.             }

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

  216.         }

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

  218. 

  219.         //connect the socket

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

  221.         {

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

  223.             return NET_CONNECT_ERROR;

  224.         }

  225. 

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

  227.         fParams = params;

  228. 

  229.         return NET_CONNECTED;

  230.     }

  231. 

  232.     net_status_t JackNetDriver::SendMasterStartSync()

  233.     {

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

  235.         //tell the master to start

  236.         SetPacketType ( &fParams, START_MASTER );

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

  238.         {

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

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

  241.         }

  242.         return NET_ROLLING;

  243.     }

  244. 

  245.     void JackNetDriver::Restart()

  246.     {

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

  248.         delete[] fTxBuffer;

  249.         delete[] fRxBuffer;

  250.         delete fNetAudioCaptureBuffer;

  251.         delete fNetAudioPlaybackBuffer;

  252.         delete fNetMidiCaptureBuffer;

  253.         delete fNetMidiPlaybackBuffer;

  254.         FreePorts();

  255.         delete[] fMidiCapturePortList;

  256.         delete[] fMidiPlaybackPortList;

  257.         fTxBuffer = NULL;

  258.         fRxBuffer = NULL;

  259.         fNetAudioCaptureBuffer = NULL;

  260.         fNetAudioPlaybackBuffer = NULL;

  261.         fNetMidiCaptureBuffer = NULL;

  262.         fNetMidiPlaybackBuffer = NULL;

  263.         fMidiCapturePortList = NULL;

  264.         fMidiPlaybackPortList = NULL;

  265.     }

  266. 

  267.     int JackNetDriver::SetParams()

  268.     {

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

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

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

  272. 

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

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

  275. 

  276.         //allocate midi ports lists

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

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

  279. 

  280.         //register jack ports

  281.         if ( AllocPorts() != 0 )

  282.         {

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

  284.             return -1;

  285.         }

  286. 

  287.         //TX header init

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

  289.         fTxHeader.fDataStream = 'r';

  290.         fTxHeader.fID = fParams.fID;

  291.         fTxHeader.fCycle = 0;

  292.         fTxHeader.fSubCycle = 0;

  293.         fTxHeader.fMidiDataSize = 0;

  294.         fTxHeader.fBitdepth = fParams.fBitdepth;

  295. 

  296.         //RX header init

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

  298.         fRxHeader.fDataStream = 's';

  299.         fRxHeader.fID = fParams.fID;

  300.         fRxHeader.fCycle = 0;

  301.         fRxHeader.fSubCycle = 0;

  302.         fRxHeader.fMidiDataSize = 0;

  303.         fRxHeader.fBitdepth = fParams.fBitdepth;

  304. 

  305.         //network buffers

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

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

  308. 

  309.         //net audio/midi buffers

  310.         fTxData = fTxBuffer + sizeof ( packet_header_t );

  311.         fRxData = fRxBuffer + sizeof ( packet_header_t );

  312. 

  313.         //midi net buffers

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

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

  316. 

  317.         //audio net buffers

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

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

  320. 

  321.         //audio netbuffer length

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

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

  324. 

  325.         //payload size

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

  327. 

  328.         return 0;

  329.     }

  330. 

  331.     int JackNetDriver::AllocPorts()

  332.     {

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

  334.         JackPort* port;

  335.         jack_port_id_t port_id;

  336.         char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  337.         char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  338.         unsigned long port_flags;

  339.         int audio_port_index;

  340.         uint midi_port_index;

  341. 

  342.         //audio

  343.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  345.         {

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

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

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

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

  350.             {

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

  352.                 return -1;

  353.             }

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

  355.             port->SetAlias ( alias );

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

  357.             fCapturePortList[audio_port_index] = port_id;

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

  359.         }

  360.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  362.         {

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

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

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

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

  367.             {

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

  369.                 return -1;

  370.             }

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

  372.             port->SetAlias ( alias );

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

  374.             fPlaybackPortList[audio_port_index] = port_id;

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

  376.         }

  377.         //midi

  378.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  380.         {

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

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

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

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

  385.             {

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

  387.                 return -1;

  388.             }

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

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

  391.             fMidiCapturePortList[midi_port_index] = port_id;

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

  393.         }

  394. 

  395.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  397.         {

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

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

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

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

  402.             {

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

  404.                 return -1;

  405.             }

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

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

  408.             fMidiPlaybackPortList[midi_port_index] = port_id;

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

  410.         }

  411. 

  412.         return 0;

  413.     }

  414. 

  415.     int JackNetDriver::FreePorts()

  416.     {

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

  418.         int audio_port_index;

  419.         uint midi_port_index;

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

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

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

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

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

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

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

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

  428.         return 0;

  429.     }

  430. 

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

  432.     {

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

  434.     }

  435. 

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

  437.     {

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

  439.     }

  440. 

  441.     int JackNetDriver::SetSyncPacket()

  442.     {

  443.         if ( fParams.fTransportSync )

  444.         {

  445.             //set the TransportData

  446. 

  447.             //copy to TxBuffer

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

  449.         }

  450.         return 0;

  451.     }

  452. 

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

  454.     {

  455.         int rx_bytes;

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

  457.         {

  458.             net_error_t error = fSocket.GetError();

  459.             if ( error == NET_NO_DATA )

  460.             {

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

  462.                 return 0;

  463.             }

  464.             else if ( error == NET_CONN_ERROR )

  465.             {

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

  467.             }

  468.             else

  469.             {

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

  471.                 return 0;

  472.             }

  473.         }

  474.         return rx_bytes;

  475.     }

  476. 

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

  478.     {

  479.         int tx_bytes;

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

  481.         {

  482.             net_error_t error = fSocket.GetError();

  483.             if ( error == NET_CONN_ERROR )

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

  485.             else

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

  487.         }

  488.         return tx_bytes;

  489.     }

  490. 

  491. //*************************************process************************************************************************

  492. 

  493.     int JackNetDriver::Read()

  494.     {

  495.         int rx_bytes;

  496.         uint recvd_midi_pckt = 0;

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

  498.         fRxHeader.fIsLastPckt = 'n';

  499.         uint midi_port_index;

  500.         int audio_port_index;

  501. 

  502.         //buffers

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

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

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

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

  507. 

  508.         //receive sync (launch the cycle)

  509.         do

  510.         {

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

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

  513.                 return rx_bytes;

  514.         }

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

  516. 

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

  518.         JackDriver::CycleTakeBeginTime();

  519. 

  520. #ifdef JACK_MONITOR

  521.         fUsecCycleStart = GetMicroSeconds();

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

  523. #endif

  524. 

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

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

  527.         {

  528.             do

  529.             {

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

  531.                     return rx_bytes;

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

  533.                 {

  534.                     switch ( rx_head->fDataType )

  535.                     {

  536.                     case 'm':	//midi

  537.                         rx_bytes = Recv ( rx_bytes, 0 );

  538.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

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

  541.                             fNetMidiCaptureBuffer->RenderToJackPorts();

  542.                         break;

  543.                     case 'a':	//audio

  544.                         rx_bytes = Recv ( fAudioRxLen, 0 );

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

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

  547.                         fRxHeader.fCycle = rx_head->fCycle;

  548.                         fRxHeader.fSubCycle = rx_head->fSubCycle;

  549.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

  551.                         break;

  552.                     case 's':	//sync

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

  554.                         fRxHeader.fCycle = rx_head->fCycle;

  555.                         return 0;

  556.                     }

  557.                 }

  558.             }

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

  560.         }

  561.         fRxHeader.fCycle = rx_head->fCycle;

  562. 

  563. 

  564. #ifdef JACK_MONITOR

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

  566. #endif

  567. 

  568.         return 0;

  569.     }

  570. 

  571.     int JackNetDriver::Write()

  572.     {

  573.         int tx_bytes, copy_size;

  574.         fTxHeader.fCycle = fRxHeader.fCycle;

  575.         fTxHeader.fSubCycle = 0;

  576.         fTxHeader.fIsLastPckt = 'n';

  577.         uint midi_port_index;

  578.         int audio_port_index;

  579. 

  580.         //buffers

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

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

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

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

  585. 

  586. #ifdef JACK_MONITOR

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

  588. #endif

  589. 

  590.         //sync

  591.         fTxHeader.fDataType = 's';

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

  593.             fTxHeader.fIsLastPckt = 'y';

  594.         memset ( fTxData, 0, fPayloadSize );

  595.         SetSyncPacket();

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

  597. 

  598. #ifdef JACK_MONITOR

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

  600. #endif

  601. 

  602.         //midi

  603.         if ( fParams.fReturnMidiChannels )

  604.         {

  605.             fTxHeader.fDataType = 'm';

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

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

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

  609.             {

  610.                 fTxHeader.fSubCycle = subproc;

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

  612.                     fTxHeader.fIsLastPckt = 'y';

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

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

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

  616.             }

  617.         }

  618. 

  619.         //audio

  620.         if ( fParams.fReturnAudioChannels )

  621.         {

  622.             fTxHeader.fDataType = 'a';

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

  624.             {

  625.                 fTxHeader.fSubCycle = subproc;

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

  627.                     fTxHeader.fIsLastPckt = 'y';

  628.                 fNetAudioPlaybackBuffer->RenderFromJackPorts ( subproc );

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

  630.                 tx_bytes = Send ( fAudioTxLen, 0 );

  631.             }

  632.         }

  633. 

  634. #ifdef JACK_MONITOR

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

  636.         fMonitor.Write ( fMeasure );

  637. #endif

  638. 

  639.         return 0;

  640.     }

  641. 

  642. //*************************************loader*******************************************************

  643. 

  644. #ifdef __cplusplus

  645.     extern "C"

  646.     {

  647. #endif

  648.         EXPORT jack_driver_desc_t* driver_get_descriptor ()

  649.         {

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

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

  652.             desc->nparams = 9;

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

  654. 

  655.             int i = 0;

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

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

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

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

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

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

  662. 

  663.             i++;

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

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

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

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

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

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

  670. 

  671.             i++;

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

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

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

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

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

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

  678. 

  679.             i++;

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

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

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

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

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

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

  686. 

  687.             i++;

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

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

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

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

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

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

  694. 

  695.             i++;

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

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

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

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

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

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

  702. 

  703.             i++;

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

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

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

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

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

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

  710. 

  711.             i++;

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

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

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

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

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

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

  718. 

  719.             i++;

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

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

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

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

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

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

  726. 

  727.             return desc;

  728.         }

  729. 

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

  731.         {

  732.             if ( SocketAPIInit() < 0 )

  733.             {

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

  735.                 return NULL;

  736.             }

  737.             const char* multicast_ip = DEFAULT_MULTICAST_IP;

  738.             char name[JACK_CLIENT_NAME_SIZE];

  739.             GetHostName ( name, JACK_CLIENT_NAME_SIZE );

  740.             int udp_port = DEFAULT_PORT;

  741.             int mtu = 1500;

  742.             uint transport_sync = 1;

  743.             jack_nframes_t period_size = 128;

  744.             jack_nframes_t sample_rate = 48000;

  745.             int audio_capture_ports = 2;

  746.             int audio_playback_ports = 2;

  747.             int midi_input_ports = 0;

  748.             int midi_output_ports = 0;

  749.             bool monitor = false;

  750. 

  751.             const JSList* node;

  752.             const jack_driver_param_t* param;

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

  754.             {

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

  756.                 switch ( param->character )

  757.                 {

  758.                 case 'a' :

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

  760.                     break;

  761.                 case 'p':

  762.                     udp_port = param->value.ui;

  763.                     break;

  764.                 case 'M':

  765.                     mtu = param->value.i;

  766.                     break;

  767.                 case 'C':

  768.                     audio_capture_ports = param->value.i;

  769.                     break;

  770.                 case 'P':

  771.                     audio_playback_ports = param->value.i;

  772.                     break;

  773.                 case 'i':

  774.                     midi_input_ports = param->value.i;

  775.                     break;

  776.                 case 'o':

  777.                     midi_output_ports = param->value.i;

  778.                     break;

  779.                 case 'n' :

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

  781.                 case 't' :

  782.                     transport_sync = param->value.ui;

  783.                 }

  784.             }

  785. 

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

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

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

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

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

  791.                 return driver;

  792. 

  793.             delete driver;

  794.             return NULL;

  795.         }

  796. 

  797. #ifdef __cplusplus

  798.     }

  799. #endif

  800. }