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.
1133 Commits
7 Branches
108MB
Tree: e3ceba7078
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e3ceba7078'
${ noResults }
jack2/common/JackNetManager.cpp

835 lines
32KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2008 Romain Moret at Grame

  3. 

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

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

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

  7. (at your option) any later version.

  8. 

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

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

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

  12. GNU General Public License for more details.

  13. 

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

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

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

  17. 

  18. */

  19. 

  20. #include "JackNetManager.h"

  21. 

  22. #define DEFAULT_MULTICAST_IP "225.3.19.154"

  23. #define DEFAULT_PORT 19000

  24. 

  25. using namespace std;

  26. 

  27. namespace Jack

  28. {

  29. //JackNetMaster******************************************************************************************************

  30. #ifdef JACK_MONITOR

  31.     uint JackNetMaster::fMeasureCnt = 50;

  32.     uint JackNetMaster::fMeasurePoints = 5;

  33.     uint JackNetMaster::fMonitorPlotOptionsCnt = 2;

  34.     string JackNetMaster::fMonitorPlotOptions[] =

  35.     {

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

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

  38.     };

  39.     string JackNetMaster::fMonitorFieldNames[] =

  40.     {

  41.         string ( "cycle start" ),

  42.         string ( "sync send" ),

  43.         string ( "send end" ),

  44.         string ( "sync recv" ),

  45.         string ( "end of cycle" )

  46.     };

  47. #endif

  48. 

  49.     JackNetMaster::JackNetMaster ( JackNetMasterManager* manager, session_params_t& params ) : fSocket()

  50.     {

  51.         jack_log ( "JackNetMaster::JackNetMaster" );

  52.         //settings

  53.         fMasterManager = manager;

  54.         fParams = params;

  55.         fSocket.CopyParams ( &fMasterManager->fSocket );

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

  57.         fClientName = const_cast<char*> ( fParams.fName );

  58.         fNetJumpCnt = 0;

  59.         fJackClient = NULL;

  60.         fRunning = false;

  61.         fSyncState = 1;

  62.         uint port_index;

  63. 

  64.         //jack audio ports

  65.         fAudioCapturePorts = new jack_port_t* [fParams.fSendAudioChannels];

  66.         for ( port_index = 0; port_index < fParams.fSendAudioChannels; port_index++ )

  67.             fAudioCapturePorts[port_index] = NULL;

  68.         fAudioPlaybackPorts = new jack_port_t* [fParams.fReturnAudioChannels];

  69.         for ( port_index = 0; port_index < fParams.fReturnAudioChannels; port_index++ )

  70.             fAudioPlaybackPorts[port_index] = NULL;

  71.         //jack midi ports

  72.         fMidiCapturePorts = new jack_port_t* [fParams.fSendMidiChannels];

  73.         for ( port_index = 0; port_index < fParams.fSendMidiChannels; port_index++ )

  74.             fMidiCapturePorts[port_index] = NULL;

  75.         fMidiPlaybackPorts = new jack_port_t* [fParams.fReturnMidiChannels];

  76.         for ( port_index = 0; port_index < fParams.fReturnMidiChannels; port_index++ )

  77.             fMidiPlaybackPorts[port_index] = NULL;

  78. 

  79.         //TX header init

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

  81.         fTxHeader.fDataStream = 's';

  82.         fTxHeader.fID = fParams.fID;

  83.         fTxHeader.fCycle = 0;

  84.         fTxHeader.fSubCycle = 0;

  85.         fTxHeader.fMidiDataSize = 0;

  86.         fTxHeader.fBitdepth = fParams.fBitdepth;

  87. 

  88.         //RX header init

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

  90.         fRxHeader.fDataStream = 'r';

  91.         fRxHeader.fID = fParams.fID;

  92.         fRxHeader.fCycle = 0;

  93.         fRxHeader.fSubCycle = 0;

  94.         fRxHeader.fMidiDataSize = 0;

  95.         fRxHeader.fBitdepth = fParams.fBitdepth;

  96. 

  97.         //network buffers

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

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

  100. 

  101.         //net audio buffers

  102.         fTxData = fTxBuffer + sizeof ( packet_header_t );

  103.         fRxData = fRxBuffer + sizeof ( packet_header_t );

  104. 

  105.         //midi net buffers

  106.         fNetMidiCaptureBuffer = new NetMidiBuffer ( &fParams, fParams.fSendMidiChannels, fTxData );

  107.         fNetMidiPlaybackBuffer = new NetMidiBuffer ( &fParams, fParams.fReturnMidiChannels, fRxData );

  108. 

  109.         //audio net buffers

  110.         fNetAudioCaptureBuffer = new NetAudioBuffer ( &fParams, fParams.fSendAudioChannels, fTxData );

  111.         fNetAudioPlaybackBuffer = new NetAudioBuffer ( &fParams, fParams.fReturnAudioChannels, fRxData );

  112. 

  113.         //audio netbuffer length

  114.         fAudioTxLen = sizeof ( packet_header_t ) + fNetAudioCaptureBuffer->GetSize();

  115.         fAudioRxLen = sizeof ( packet_header_t ) + fNetAudioPlaybackBuffer->GetSize();

  116. 

  117.         //payload size

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

  119. 

  120.         //monitor

  121. #ifdef JACK_MONITOR

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

  123. 		plot_name += string ( "_master" );

  124. 		//plot_name += ( fEngineControl->fSyncMode ) ? string ( "sync" ) : string ( "async" );

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

  126.         fMeasure = new float[JackNetMaster::fMeasurePoints];

  127.         fMonitor->SetPlotFile ( JackNetMaster::fMonitorPlotOptions, JackNetMaster::fMonitorPlotOptionsCnt,

  128. 								JackNetMaster::fMonitorFieldNames, JackNetMaster::fMeasurePoints );

  129. #endif

  130.     }

  131. 

  132.     JackNetMaster::~JackNetMaster()

  133.     {

  134.         jack_log ( "JackNetMaster::~JackNetMaster, ID %u.", fParams.fID );

  135.         if ( fJackClient )

  136.         {

  137.             jack_deactivate ( fJackClient );

  138.             FreePorts();

  139.             jack_client_close ( fJackClient );

  140.         }

  141.         fSocket.Close();

  142.         delete fNetAudioCaptureBuffer;

  143.         delete fNetAudioPlaybackBuffer;

  144.         delete fNetMidiCaptureBuffer;

  145.         delete fNetMidiPlaybackBuffer;

  146.         delete[] fAudioCapturePorts;

  147.         delete[] fAudioPlaybackPorts;

  148.         delete[] fMidiCapturePorts;

  149.         delete[] fMidiPlaybackPorts;

  150.         delete[] fTxBuffer;

  151.         delete[] fRxBuffer;

  152. #ifdef JACK_MONITOR

  153.         fMonitor->Save();

  154.         delete[] fMeasure;

  155.         delete fMonitor;

  156. #endif

  157.     }

  158. 

  159.     bool JackNetMaster::Init()

  160.     {

  161.         jack_log ( "JackNetMaster::Init, ID %u.", fParams.fID );

  162.         session_params_t params;

  163.         int msec_timeout = 1000;

  164.         uint attempt = 0;

  165.         int rx_bytes = 0;

  166. 

  167.         //socket

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

  169.         {

  170.             jack_error ( "Can't create socket : %s", StrError ( NET_ERROR_CODE ) );

  171.             return false;

  172.         }

  173. 

  174.         //timeout on receive (for init)

  175.         if ( fSocket.SetTimeOut ( msec_timeout ) < 0 )

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

  177. 

  178.         //connect

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

  180.         {

  181.             jack_error ( "Can't connect : %s", StrError ( NET_ERROR_CODE ) );

  182.             return false;

  183.         }

  184. 

  185.         //send 'SLAVE_SETUP' until 'START_MASTER' received

  186.         jack_info ( "Sending parameters to %s ...", fParams.fSlaveNetName );

  187.         do

  188.         {

  189.             SetPacketType ( &fParams, SLAVE_SETUP );

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

  191.                 jack_error ( "Error in send : ", StrError ( NET_ERROR_CODE ) );

  192.             if ( ( ( rx_bytes = fSocket.Recv ( &params, sizeof ( session_params_t ), 0 ) ) == SOCKET_ERROR ) && ( fSocket.GetError() != NET_NO_DATA ) )

  193.             {

  194.                 jack_error ( "Problem with network." );

  195.                 return false;

  196.             }

  197.         }

  198.         while ( ( GetPacketType ( &params ) != START_MASTER ) && ( ++attempt < 5 ) );

  199.         if ( attempt == 5 )

  200.         {

  201.             jack_error ( "Slave doesn't respond, exiting." );

  202.             return false;

  203.         }

  204. 

  205.         //set the new timeout for the socket

  206.         if ( SetRxTimeout ( &fSocket, &fParams ) == SOCKET_ERROR )

  207.         {

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

  209.             return false;

  210.         }

  211. 

  212.         //jack client and process

  213.         jack_status_t status;

  214.         jack_options_t options = JackNullOption;

  215.         if ( ( fJackClient = jack_client_open ( fClientName, options, &status, NULL ) ) == NULL )

  216.         {

  217.             jack_error ( "Can't open a new jack client." );

  218.             return false;

  219.         }

  220. 

  221.         jack_set_process_callback ( fJackClient, SetProcess, this );

  222. 

  223.         //port registering

  224.         uint i;

  225.         char name[24];

  226.         jack_nframes_t port_latency = jack_get_buffer_size ( fJackClient );

  227.         unsigned long port_flags;

  228.         //audio

  229.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  230.         for ( i = 0; i < fParams.fSendAudioChannels; i++ )

  231.         {

  232.             sprintf ( name, "to_slave_%d", i+1 );

  233.             if ( ( fAudioCapturePorts[i] = jack_port_register ( fJackClient, name, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0 ) ) == NULL )

  234.                 goto fail;

  235.             jack_port_set_latency ( fAudioCapturePorts[i], port_latency );

  236.         }

  237.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  238.         for ( i = 0; i < fParams.fReturnAudioChannels; i++ )

  239.         {

  240.             sprintf ( name, "from_slave_%d", i+1 );

  241.             if ( ( fAudioPlaybackPorts[i] = jack_port_register ( fJackClient, name, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0 ) ) == NULL )

  242.                 goto fail;

  243.             jack_port_set_latency ( fAudioPlaybackPorts[i], port_latency );

  244.         }

  245.         //midi

  246.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  247.         for ( i = 0; i < fParams.fSendMidiChannels; i++ )

  248.         {

  249.             sprintf ( name, "midi_to_slave_%d", i+1 );

  250.             if ( ( fMidiCapturePorts[i] = jack_port_register ( fJackClient, name, JACK_DEFAULT_MIDI_TYPE, port_flags, 0 ) ) == NULL )

  251.                 goto fail;

  252.             jack_port_set_latency ( fMidiCapturePorts[i], port_latency );

  253.         }

  254.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  255.         for ( i = 0; i < fParams.fReturnMidiChannels; i++ )

  256.         {

  257.             sprintf ( name, "midi_from_slave_%d", i+1 );

  258.             if ( ( fMidiPlaybackPorts[i] = jack_port_register ( fJackClient, name, JACK_DEFAULT_MIDI_TYPE, port_flags, 0 ) ) == NULL )

  259.                 goto fail;

  260.             jack_port_set_latency ( fMidiPlaybackPorts[i], port_latency );

  261.         }

  262. 

  263.         fRunning = true;

  264. 

  265.         //finally activate jack client

  266.         if ( jack_activate ( fJackClient ) != 0 )

  267.         {

  268.             jack_error ( "Can't activate jack client." );

  269.             goto fail;

  270.         }

  271. 

  272.         jack_info ( "NetJack new master started." );

  273. 

  274.         return true;

  275. 

  276. fail:

  277.         FreePorts();

  278.         jack_client_close ( fJackClient );

  279.         fJackClient = NULL;

  280.         return false;

  281.     }

  282. 

  283.     void JackNetMaster::FreePorts()

  284.     {

  285.         jack_log ( "JackNetMaster::FreePorts, ID %u", fParams.fID );

  286.         uint port_index;

  287.         for ( port_index = 0; port_index < fParams.fSendAudioChannels; port_index++ )

  288.             if ( fAudioCapturePorts[port_index] )

  289.                 jack_port_unregister ( fJackClient, fAudioCapturePorts[port_index] );

  290.         for ( port_index = 0; port_index < fParams.fReturnAudioChannels; port_index++ )

  291.             if ( fAudioPlaybackPorts[port_index] )

  292.                 jack_port_unregister ( fJackClient, fAudioPlaybackPorts[port_index] );

  293.         for ( port_index = 0; port_index < fParams.fSendMidiChannels; port_index++ )

  294.             if ( fMidiCapturePorts[port_index] )

  295.                 jack_port_unregister ( fJackClient, fMidiCapturePorts[port_index] );

  296.         for ( port_index = 0; port_index < fParams.fReturnMidiChannels; port_index++ )

  297.             if ( fMidiPlaybackPorts[port_index] )

  298.                 jack_port_unregister ( fJackClient, fMidiPlaybackPorts[port_index] );

  299.     }

  300. 

  301.     void JackNetMaster::Exit()

  302.     {

  303.         jack_log ( "JackNetMaster::Exit, ID %u", fParams.fID );

  304.         //stop process

  305.         fRunning = false;

  306.         //send a 'multicast euthanasia request' - new socket is required on macosx

  307.         jack_info ( "Exiting '%s'", fParams.fName );

  308.         SetPacketType ( &fParams, KILL_MASTER );

  309.         JackNetSocket mcast_socket ( fMasterManager->fMulticastIP, fSocket.GetPort() );

  310.         if ( mcast_socket.NewSocket() == SOCKET_ERROR )

  311.             jack_error ( "Can't create socket : %s", StrError ( NET_ERROR_CODE ) );

  312.         if ( mcast_socket.SendTo ( &fParams, sizeof ( session_params_t ), 0, fMasterManager->fMulticastIP ) == SOCKET_ERROR )

  313.             jack_error ( "Can't send suicide request : %s", StrError ( NET_ERROR_CODE ) );

  314.         mcast_socket.Close();

  315.     }

  316. 

  317.     int JackNetMaster::SetSyncPacket()

  318.     {

  319.         if ( fParams.fTransportSync )

  320.         {

  321.             //set the TransportData

  322. 

  323.             //copy to TxBuffer

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

  325.         }

  326.         return 0;

  327.     }

  328. 

  329.     int JackNetMaster::Send ( char* buffer, size_t size, int flags )

  330.     {

  331.         int tx_bytes;

  332.         if ( ( tx_bytes = fSocket.Send ( buffer, size, flags ) ) == SOCKET_ERROR )

  333.         {

  334.             net_error_t error = fSocket.GetError();

  335.             if ( error == NET_CONN_ERROR )

  336.             {

  337.                 //fatal connection issue, exit

  338.                 jack_error ( "'%s' : %s, please check network connection with '%s'.",

  339.                              fParams.fName, StrError ( NET_ERROR_CODE ), fParams.fSlaveNetName );

  340.                 Exit();

  341.                 return 0;

  342.             }

  343.             else

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

  345.         }

  346.         return tx_bytes;

  347.     }

  348. 

  349.     int JackNetMaster::Recv ( size_t size, int flags )

  350.     {

  351.         int rx_bytes;

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

  353.         {

  354.             net_error_t error = fSocket.GetError();

  355.             if ( error == NET_NO_DATA )

  356.             {

  357.                 //too much receive failure, react...

  358.                 if ( ++fNetJumpCnt == 50 )

  359.                 {

  360.                     jack_error ( "Connection lost, is %s still running ?", fParams.fName );

  361.                     fNetJumpCnt = 0;

  362.                 }

  363.                 return 0;

  364.             }

  365.             else if ( error == NET_CONN_ERROR )

  366.             {

  367.                 //fatal connection issue, exit

  368.                 jack_error ( "'%s' : %s, please check network connection with '%s'.",

  369.                              fParams.fName, StrError ( NET_ERROR_CODE ), fParams.fSlaveNetName );

  370.                 Exit();

  371.                 return 0;

  372.             }

  373.             else

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

  375.         }

  376.         return rx_bytes;

  377.     }

  378. 

  379.     int JackNetMaster::SetProcess ( jack_nframes_t nframes, void* arg )

  380.     {

  381.         JackNetMaster* master = static_cast<JackNetMaster*> ( arg );

  382.         return master->Process();

  383.     }

  384. 

  385.     int JackNetMaster::Process()

  386.     {

  387.         if ( !fRunning )

  388.             return 0;

  389. 

  390.         int tx_bytes, rx_bytes, copy_size;

  391.         size_t midi_recvd_pckt = 0;

  392.         fTxHeader.fCycle++;

  393.         fTxHeader.fSubCycle = 0;

  394.         fTxHeader.fIsLastPckt = 'n';

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

  396. 

  397. #ifdef JACK_MONITOR

  398. 		fMeasureId = 0;

  399.         fMeasure[fMeasureId++] = ( (float)jack_frames_since_cycle_start( fJackClient ) /(float)fParams.fPeriodSize ) * 100.f;

  400. #endif

  401. 

  402.         //buffers

  403.         uint port_index;

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

  405.             fNetMidiCaptureBuffer->SetBuffer(port_index,

  406. 											static_cast<JackMidiBuffer*> ( jack_port_get_buffer ( fMidiCapturePorts[port_index],

  407.                                             fParams.fPeriodSize )));

  408.         for ( port_index = 0; port_index < fParams.fSendAudioChannels; port_index++ )

  409.             fNetAudioCaptureBuffer->SetBuffer(port_index,

  410.                                              static_cast<sample_t*> ( jack_port_get_buffer ( fAudioCapturePorts[port_index],

  411.                                              fParams.fPeriodSize )));

  412.         for ( port_index = 0; port_index < fParams.fReturnMidiChannels; port_index++ )

  413.             fNetMidiPlaybackBuffer->SetBuffer(port_index,

  414.                                              static_cast<JackMidiBuffer*> ( jack_port_get_buffer ( fMidiPlaybackPorts[port_index],

  415.                                              fParams.fPeriodSize )));

  416.         for ( port_index = 0; port_index < fParams.fReturnAudioChannels; port_index++ )

  417.             fNetAudioPlaybackBuffer->SetBuffer(port_index,

  418.                                               static_cast<sample_t*> ( jack_port_get_buffer ( fAudioPlaybackPorts[port_index],

  419.                                               fParams.fPeriodSize )));

  420. 

  421.         //send ------------------------------------------------------------------------------------------------------------------

  422.         //sync

  423.         fTxHeader.fDataType = 's';

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

  425.             fTxHeader.fIsLastPckt = 'y';

  426.         memset ( fTxData, 0, fPayloadSize );

  427.         SetSyncPacket();

  428.         tx_bytes = Send ( fTxBuffer, fParams.fMtu, 0 );

  429.         if ( ( tx_bytes == 0 ) || ( tx_bytes == SOCKET_ERROR ) )

  430.             return tx_bytes;

  431. 

  432. #ifdef JACK_MONITOR

  433.         fMeasure[fMeasureId++] = ( (float)jack_frames_since_cycle_start( fJackClient ) /(float)fParams.fPeriodSize ) * 100.f;

  434. #endif

  435. 

  436.         //midi

  437.         if ( fParams.fSendMidiChannels )

  438.         {

  439.             fTxHeader.fDataType = 'm';

  440.             fTxHeader.fMidiDataSize = fNetMidiCaptureBuffer->RenderFromJackPorts();

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

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

  443.             {

  444.                 fTxHeader.fSubCycle = subproc;

  445.                 if ( ( subproc == ( fTxHeader.fNMidiPckt - 1 ) ) && !fParams.fSendAudioChannels )

  446.                     fTxHeader.fIsLastPckt = 'y';

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

  448.                 copy_size = fNetMidiCaptureBuffer->RenderToNetwork ( subproc, fTxHeader.fMidiDataSize );

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

  450.                 if ( tx_bytes < 1 )

  451.                     return tx_bytes;

  452.             }

  453.         }

  454. 

  455.         //audio

  456.         if ( fParams.fSendAudioChannels )

  457.         {

  458.             fTxHeader.fDataType = 'a';

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

  460.             {

  461.                 fTxHeader.fSubCycle = subproc;

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

  463.                     fTxHeader.fIsLastPckt = 'y';

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

  465.                 fNetAudioCaptureBuffer->RenderFromJackPorts ( subproc );

  466.                 tx_bytes = Send ( fTxBuffer, fAudioTxLen, 0 );

  467.                 if ( tx_bytes < 1 )

  468.                     return tx_bytes;

  469.             }

  470.         }

  471. 

  472. #ifdef JACK_MONITOR

  473.         fMeasure[fMeasureId++] = ( (float)jack_frames_since_cycle_start( fJackClient ) /(float)fParams.fPeriodSize ) * 100.f;

  474. #endif

  475. 

  476.         //receive --------------------------------------------------------------------------------------------------------------------

  477.         //sync

  478.         do

  479.         {

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

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

  482.                 return rx_bytes;

  483.         }

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

  485. 

  486. #ifdef JACK_MONITOR

  487.         fMeasure[fMeasureId++] = ( (float)jack_frames_since_cycle_start( fJackClient ) /(float)fParams.fPeriodSize ) * 100.f;

  488. #endif

  489. 

  490.         if ( fParams.fReturnMidiChannels || fParams.fReturnAudioChannels )

  491.         {

  492.             do

  493.             {

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

  495.                     return rx_bytes;

  496.                 if ( rx_bytes && ( rx_head->fDataStream == 'r' ) && ( rx_head->fID == fParams.fID ) )

  497.                 {

  498.                     switch ( rx_head->fDataType )

  499.                     {

  500.                     case 'm':	//midi

  501.                         rx_bytes = Recv ( rx_bytes, 0 );

  502.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

  503.                         fNetMidiPlaybackBuffer->RenderFromNetwork ( rx_head->fSubCycle, rx_bytes - sizeof ( packet_header_t ) );

  504.                         if ( ++midi_recvd_pckt == rx_head->fNMidiPckt )

  505.                             fNetMidiPlaybackBuffer->RenderToJackPorts();

  506.                         fNetJumpCnt = 0;

  507.                         break;

  508.                     case 'a':	//audio

  509.                         rx_bytes = Recv ( fAudioRxLen, 0 );

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

  511.                             jack_error ( "Packet(s) missing from '%s'...", fParams.fName );

  512.                         fRxHeader.fCycle = rx_head->fCycle;

  513.                         fRxHeader.fSubCycle = rx_head->fSubCycle;

  514.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

  515.                         fNetAudioPlaybackBuffer->RenderToJackPorts ( rx_head->fSubCycle );

  516.                         fNetJumpCnt = 0;

  517.                         break;

  518.                     case 's':	//sync

  519.                         jack_error ( "NetMaster receive sync packets instead of data." );

  520.                         fRxHeader.fCycle = rx_head->fCycle;

  521.                         return 0;

  522.                     }

  523.                 }

  524.             }

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

  526.         }

  527. 

  528. #ifdef JACK_MONITOR

  529.         fMeasure[fMeasureId++] = ( (float)jack_frames_since_cycle_start( fJackClient ) /(float)fParams.fPeriodSize ) * 100.f;

  530.         fMonitor->Write ( fMeasure );

  531. #endif

  532.         return 0;

  533.     }

  534. 

  535. //JackNetMasterManager***********************************************************************************************

  536. 

  537.     JackNetMasterManager::JackNetMasterManager ( jack_client_t* client, const JSList* params ) : fSocket()

  538.     {

  539.         jack_log ( "JackNetMasterManager::JackNetMasterManager" );

  540.         fManagerClient = client;

  541.         fManagerName = jack_get_client_name ( fManagerClient );

  542.         fMulticastIP = DEFAULT_MULTICAST_IP;

  543.         fSocket.SetPort ( DEFAULT_PORT );

  544.         fGlobalID = 0;

  545.         fRunning = true;

  546. 

  547.         const JSList* node;

  548.         const jack_driver_param_t* param;

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

  550.         {

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

  552.             switch ( param->character )

  553.             {

  554.             case 'a' :

  555.                 fMulticastIP = strdup ( param->value.str );

  556.                 break;

  557.             case 'p':

  558.                 fSocket.SetPort ( param->value.ui );

  559.             }

  560.         }

  561. 

  562.         //set sync callback

  563.         jack_set_sync_callback ( fManagerClient, SetSyncCallback, this );

  564. 

  565.         //activate the client (for sync callback)

  566.         if ( jack_activate ( fManagerClient ) != 0 )

  567.             jack_error ( "Can't activate the network manager client, transport disabled." );

  568. 

  569.         //launch the manager thread

  570.         if ( jack_client_create_thread ( fManagerClient, &fManagerThread, 0, 0, NetManagerThread, this ) )

  571.             jack_error ( "Can't create the network manager control thread." );

  572.     }

  573. 

  574.     JackNetMasterManager::~JackNetMasterManager()

  575.     {

  576.         jack_log ( "JackNetMasterManager::~JackNetMasterManager" );

  577.         Exit();

  578.         master_list_t::iterator it;

  579.         for ( it = fMasterList.begin(); it != fMasterList.end(); it++ )

  580.             delete ( *it );

  581.         fSocket.Close();

  582.         SocketAPIEnd();

  583.     }

  584. 

  585.     int JackNetMasterManager::SetSyncCallback ( jack_transport_state_t state, jack_position_t* pos, void* arg )

  586.     {

  587.         JackNetMasterManager* master_manager = static_cast<JackNetMasterManager*>(arg);

  588.         return master_manager->SyncCallback ( state, pos );

  589.     }

  590. 

  591.     int JackNetMasterManager::SyncCallback ( jack_transport_state_t state, jack_position_t* pos )

  592.     {

  593.         //check sync state for every master in the list

  594.         int ret = 1;

  595.         master_list_it_t it;

  596.         for ( it = fMasterList.begin(); it != fMasterList.end(); it++ )

  597.             if ( ( *it )->fSyncState == 0 )

  598.                 ret = 0;

  599.         jack_log ( "JackNetMasterManager::SyncCallback returns '%s'", ( ret ) ? "true" : "false" );

  600.         return ret;

  601.     }

  602. 

  603.     void* JackNetMasterManager::NetManagerThread ( void* arg )

  604.     {

  605.         JackNetMasterManager* master_manager = static_cast<JackNetMasterManager*> ( arg );

  606.         jack_info ( "Starting Jack Network Manager." );

  607.         jack_info ( "Listening on '%s:%d'", master_manager->fMulticastIP, master_manager->fSocket.GetPort() );

  608.         master_manager->Run();

  609.         return NULL;

  610.     }

  611. 

  612.     void JackNetMasterManager::Run()

  613.     {

  614.         jack_log ( "JackNetMasterManager::Run" );

  615.         //utility variables

  616.         int msec_timeout = 2000;

  617.         int attempt = 0;

  618. 

  619.         //data

  620.         session_params_t params;

  621.         int rx_bytes = 0;

  622.         JackNetMaster* net_master;

  623. 

  624.         //init socket API (win32)

  625.         if ( SocketAPIInit() < 0 )

  626.         {

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

  628.             return;

  629.         }

  630. 

  631.         //socket

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

  633.         {

  634.             jack_error ( "Can't create the network management input socket : %s", StrError ( NET_ERROR_CODE ) );

  635.             return;

  636.         }

  637. 

  638.         //bind the socket to the local port

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

  640.         {

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

  642.             fSocket.Close();

  643.             return;

  644.         }

  645. 

  646.         //join multicast group

  647.         if ( fSocket.JoinMCastGroup ( fMulticastIP ) == SOCKET_ERROR )

  648.             jack_error ( "Can't join multicast group : %s", StrError ( NET_ERROR_CODE ) );

  649. 

  650.         //local loop

  651.         if ( fSocket.SetLocalLoop() == SOCKET_ERROR )

  652.             jack_error ( "Can't set local loop : %s", StrError ( NET_ERROR_CODE ) );

  653. 

  654.         //set a timeout on the multicast receive (the thread can now be cancelled)

  655.         if ( fSocket.SetTimeOut ( msec_timeout ) == SOCKET_ERROR )

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

  657. 

  658.         jack_info ( "Waiting for a slave..." );

  659. 

  660.         //main loop, wait for data, deal with it and wait again

  661.         do

  662.         {

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

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

  665.             {

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

  667.                 if ( ++attempt == 10 )

  668.                 {

  669.                     jack_error ( "Can't receive on the socket, exiting net manager." );

  670.                     return;

  671.                 }

  672.             }

  673.             if ( rx_bytes == sizeof ( session_params_t ) )

  674.             {

  675.                 switch ( GetPacketType ( &params ) )

  676.                 {

  677.                 case SLAVE_AVAILABLE:

  678.                     if ( ( net_master = MasterInit ( params ) ) )

  679.                         SessionParamsDisplay ( &net_master->fParams );

  680.                     else

  681.                         jack_error ( "Can't init new net master..." );

  682.                     jack_info ( "Waiting for a slave..." );

  683.                     break;

  684.                 case KILL_MASTER:

  685.                     KillMaster ( &params );

  686.                     jack_info ( "Waiting for a slave..." );

  687.                     break;

  688.                 default:

  689.                     break;

  690.                 }

  691.             }

  692.         }

  693.         while ( fRunning );

  694.     }

  695. 

  696.     void JackNetMasterManager::Exit()

  697.     {

  698.         jack_log ( "JackNetMasterManager::Exit" );

  699.         fRunning = false;

  700.         jack_client_stop_thread ( fManagerClient, fManagerThread );

  701.         jack_info ( "Exiting net manager..." );

  702.     }

  703. 

  704.     JackNetMaster* JackNetMasterManager::MasterInit ( session_params_t& params )

  705.     {

  706.         jack_log ( "JackNetMasterManager::MasterInit, Slave : %s", params.fName );

  707.         //settings

  708.         fSocket.GetName ( params.fMasterNetName );

  709.         params.fID = ++fGlobalID;

  710.         params.fSampleRate = jack_get_sample_rate ( fManagerClient );

  711.         params.fPeriodSize = jack_get_buffer_size ( fManagerClient );

  712.         params.fBitdepth = 0;

  713.         SetFramesPerPacket ( &params );

  714.         SetSlaveName ( params );

  715. 

  716.         //create a new master and add it to the list

  717.         JackNetMaster* master = new JackNetMaster ( this, params );

  718.         if ( master->Init() )

  719.         {

  720.             fMasterList.push_back ( master );

  721.             return master;

  722.         }

  723.         delete master;

  724.         return NULL;

  725.     }

  726. 

  727.     void JackNetMasterManager::SetSlaveName ( session_params_t& params )

  728.     {

  729.         jack_log ( "JackNetMasterManager::SetSlaveName" );

  730.         master_list_it_t it;

  731.         for ( it = fMasterList.begin(); it != fMasterList.end(); it++ )

  732.             if ( strcmp ( ( *it )->fParams.fName, params.fName ) == 0 )

  733.                 sprintf ( params.fName, "%s-%u", params.fName, params.fID );

  734.     }

  735. 

  736.     master_list_it_t JackNetMasterManager::FindMaster ( uint32_t id )

  737.     {

  738.         jack_log ( "JackNetMasterManager::FindMaster, ID %u.", id );

  739.         master_list_it_t it;

  740.         for ( it = fMasterList.begin(); it != fMasterList.end(); it++ )

  741.             if ( ( *it )->fParams.fID == id )

  742.                 return it;

  743.         return it;

  744.     }

  745. 

  746.     void JackNetMasterManager::KillMaster ( session_params_t* params )

  747.     {

  748.         jack_log ( "JackNetMasterManager::KillMaster, ID %u.", params->fID );

  749.         master_list_it_t master = FindMaster ( params->fID );

  750.         if ( master != fMasterList.end() )

  751.         {

  752.             fMasterList.erase ( master );

  753.             delete *master;

  754.         }

  755.     }

  756. }//namespace

  757. 

  758. static Jack::JackNetMasterManager* master_manager = NULL;

  759. 

  760. #ifdef __cplusplus

  761. extern "C"

  762. {

  763. #endif

  764. 

  765.     EXPORT jack_driver_desc_t* jack_get_descriptor()

  766.     {

  767.         jack_driver_desc_t *desc;

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

  769. 

  770.         strcpy(desc->name, "netmanager");

  771.         desc->nparams = 2;

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

  773. 

  774.         int i = 0;

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

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

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

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

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

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

  781. 

  782.         i++;

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

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

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

  786.         desc->params[i].value.i = DEFAULT_PORT;

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

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

  789. 

  790.         return desc;

  791.     }

  792. 

  793.     EXPORT int jack_internal_initialize ( jack_client_t* jack_client, const JSList* params )

  794.     {

  795.         if ( master_manager )

  796.         {

  797.             jack_error ( "Master Manager already loaded" );

  798.             return 1;

  799.         }

  800.         else

  801.         {

  802.             jack_log ( "Loading Master Manager" );

  803.             master_manager = new Jack::JackNetMasterManager ( jack_client, params );

  804.             return ( master_manager ) ? 0 : 1;

  805.         }

  806.     }

  807. 

  808.     EXPORT int jack_initialize ( jack_client_t* jack_client, const char* load_init )

  809.     {

  810.         JSList* params = NULL;

  811.         jack_driver_desc_t* desc = jack_get_descriptor();

  812.         Jack::JackArgParser parser ( load_init );

  813. 

  814.         if ( parser.GetArgc() > 0)

  815.         {

  816.             if ( parser.ParseParams ( desc, &params) < 0 )

  817.                 jack_error ( "Internal client JackArgParser::ParseParams error." );

  818.         }

  819. 

  820.         return jack_internal_initialize(jack_client, params);

  821.     }

  822. 

  823.     EXPORT void jack_finish ( void* arg )

  824.     {

  825.         if ( master_manager )

  826.         {

  827.             jack_log ( "Unloading Master Manager" );

  828.             delete master_manager;

  829.             master_manager = NULL;

  830.         }

  831.     }

  832. #ifdef __cplusplus

  833. }

  834. #endif