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/JackNetManager.cpp

830 lines
31KB
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 = 512;

  32.     uint JackNetMaster::fMeasurePoints = 5;

  33.     std::string JackNetMaster::fMonitorPlotOptions[] =

  34.     {

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

  36.         std::string ( "set ylabel \"audio frames\"" )

  37.     };

  38.     std::string JackNetMaster::fMonitorFieldNames[] =

  39.     {

  40.         std::string ( "cycle start" ),

  41.         std::string ( "sync send" ),

  42.         std::string ( "send end" ),

  43.         std::string ( "sync recv" ),

  44.         std::string ( "end of cycle" )

  45.     };

  46. #endif

  47. 

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

  49.     {

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

  51.         //settings

  52.         fMasterManager = manager;

  53.         fParams = params;

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

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

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

  57.         fNetJumpCnt = 0;

  58.         fJackClient = NULL;

  59.         fRunning = false;

  60.         fSyncState = 1;

  61.         uint port_index;

  62. 

  63.         //jack audio ports

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

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

  66.             fAudioCapturePorts[port_index] = NULL;

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

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

  69.             fAudioPlaybackPorts[port_index] = NULL;

  70.         //jack midi ports

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

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

  73.             fMidiCapturePorts[port_index] = NULL;

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

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

  76.             fMidiPlaybackPorts[port_index] = NULL;

  77. 

  78.         //TX header init

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

  80.         fTxHeader.fDataStream = 's';

  81.         fTxHeader.fID = fParams.fID;

  82.         fTxHeader.fCycle = 0;

  83.         fTxHeader.fSubCycle = 0;

  84.         fTxHeader.fMidiDataSize = 0;

  85.         fTxHeader.fBitdepth = fParams.fBitdepth;

  86. 

  87.         //RX header init

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

  89.         fRxHeader.fDataStream = 'r';

  90.         fRxHeader.fID = fParams.fID;

  91.         fRxHeader.fCycle = 0;

  92.         fRxHeader.fSubCycle = 0;

  93.         fRxHeader.fMidiDataSize = 0;

  94.         fRxHeader.fBitdepth = fParams.fBitdepth;

  95. 

  96.         //network buffers

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

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

  99. 

  100.         //net audio buffers

  101.         fTxData = fTxBuffer + sizeof ( packet_header_t );

  102.         fRxData = fRxBuffer + sizeof ( packet_header_t );

  103. 

  104.         //midi net buffers

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

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

  107. 

  108.         //audio net buffers

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

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

  111. 

  112.         //audio netbuffer length

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

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

  115. 

  116.         //payload size

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

  118. 

  119.         //monitor

  120. #ifdef JACK_MONITOR

  121.         fMeasure = new jack_nframes_t[JackNetMaster::fMeasurePoints];

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

  123.         fMonitor.SetPlotFile ( plot_file_name, fMonitorPlotOptions, 2, fMonitorFieldNames, 5 );

  124. #endif

  125.     }

  126. 

  127.     JackNetMaster::~JackNetMaster()

  128.     {

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

  130.         if ( fJackClient )

  131.         {

  132.             jack_deactivate ( fJackClient );

  133.             FreePorts();

  134.             jack_client_close ( fJackClient );

  135.         }

  136.         fSocket.Close();

  137.         delete fNetAudioCaptureBuffer;

  138.         delete fNetAudioPlaybackBuffer;

  139.         delete fNetMidiCaptureBuffer;

  140.         delete fNetMidiPlaybackBuffer;

  141.         delete[] fAudioCapturePorts;

  142.         delete[] fAudioPlaybackPorts;

  143.         delete[] fMidiCapturePorts;

  144.         delete[] fMidiPlaybackPorts;

  145.         delete[] fTxBuffer;

  146.         delete[] fRxBuffer;

  147. #ifdef JACK_MONITOR

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

  149.         fMonitor.Save ( filename );

  150.         delete[] fMeasure;

  151. #endif

  152.     }

  153. 

  154.     bool JackNetMaster::Init()

  155.     {

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

  157.         session_params_t params;

  158.         int msec_timeout = 1000;

  159.         uint attempt = 0;

  160.         int rx_bytes = 0;

  161. 

  162.         //socket

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

  164.         {

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

  166.             return false;

  167.         }

  168. 

  169.         //timeout on receive (for init)

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

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

  172. 

  173.         //connect

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

  175.         {

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

  177.             return false;

  178.         }

  179. 

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

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

  182.         do

  183.         {

  184.             SetPacketType ( &fParams, SLAVE_SETUP );

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

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

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

  188.             {

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

  190.                 return false;

  191.             }

  192.         }

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

  194.         if ( attempt == 5 )

  195.         {

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

  197.             return false;

  198.         }

  199. 

  200.         //set the new timeout for the socket

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

  202.         {

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

  204.             return false;

  205.         }

  206. 

  207.         //jack client and process

  208.         jack_status_t status;

  209.         jack_options_t options = JackNullOption;

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

  211.         {

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

  213.             return false;

  214.         }

  215. 

  216.         jack_set_process_callback ( fJackClient, SetProcess, this );

  217. 

  218.         //port registering

  219.         uint i;

  220.         char name[24];

  221.         jack_nframes_t port_latency = jack_get_buffer_size ( fJackClient );

  222.         unsigned long port_flags;

  223.         //audio

  224.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  226.         {

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

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

  229.                 goto fail;

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

  231.         }

  232.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  234.         {

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

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

  237.                 goto fail;

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

  239.         }

  240.         //midi

  241.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  243.         {

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

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

  246.                 goto fail;

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

  248.         }

  249.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  251.         {

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

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

  254.                 goto fail;

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

  256.         }

  257. 

  258.         fRunning = true;

  259. 

  260.         //finally activate jack client

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

  262.         {

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

  264.             goto fail;

  265.         }

  266. 

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

  268. 

  269.         return true;

  270. 

  271. fail:

  272.         FreePorts();

  273.         jack_client_close ( fJackClient );

  274.         fJackClient = NULL;

  275.         return false;

  276.     }

  277. 

  278.     void JackNetMaster::FreePorts()

  279.     {

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

  281.         uint port_index;

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

  283.             if ( fAudioCapturePorts[port_index] )

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

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

  286.             if ( fAudioPlaybackPorts[port_index] )

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

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

  289.             if ( fMidiCapturePorts[port_index] )

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

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

  292.             if ( fMidiPlaybackPorts[port_index] )

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

  294.     }

  295. 

  296.     void JackNetMaster::Exit()

  297.     {

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

  299.         //stop process

  300.         fRunning = false;

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

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

  303.         SetPacketType ( &fParams, KILL_MASTER );

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

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

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

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

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

  309.         mcast_socket.Close();

  310.     }

  311. 

  312.     int JackNetMaster::SetSyncPacket()

  313.     {

  314.         if ( fParams.fTransportSync )

  315.         {

  316.             //set the TransportData

  317. 

  318.             //copy to TxBuffer

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

  320.         }

  321.         return 0;

  322.     }

  323. 

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

  325.     {

  326.         int tx_bytes;

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

  328.         {

  329.             net_error_t error = fSocket.GetError();

  330.             if ( error == NET_CONN_ERROR )

  331.             {

  332.                 //fatal connection issue, exit

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

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

  335.                 Exit();

  336.                 return 0;

  337.             }

  338.             else

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

  340.         }

  341.         return tx_bytes;

  342.     }

  343. 

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

  345.     {

  346.         int rx_bytes;

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

  348.         {

  349.             net_error_t error = fSocket.GetError();

  350.             if ( error == NET_NO_DATA )

  351.             {

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

  353.                 if ( ++fNetJumpCnt == 50 )

  354.                 {

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

  356.                     fNetJumpCnt = 0;

  357.                 }

  358.                 return 0;

  359.             }

  360.             else if ( error == NET_CONN_ERROR )

  361.             {

  362.                 //fatal connection issue, exit

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

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

  365.                 Exit();

  366.                 return 0;

  367.             }

  368.             else

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

  370.         }

  371.         return rx_bytes;

  372.     }

  373. 

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

  375.     {

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

  377.         return master->Process();

  378.     }

  379. 

  380.     int JackNetMaster::Process()

  381.     {

  382.         if ( !fRunning )

  383.             return 0;

  384. 

  385.         int tx_bytes, rx_bytes, copy_size;

  386.         size_t midi_recvd_pckt = 0;

  387.         fTxHeader.fCycle++;

  388.         fTxHeader.fSubCycle = 0;

  389.         fTxHeader.fIsLastPckt = 'n';

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

  391. 

  392. #ifdef JACK_MONITOR

  393.         NetMeasure<jack_nframes_t> measure;

  394.         fMeasure[0] = jack_frames_since_cycle_start( fJackClient );

  395. #endif

  396. 

  397.         //buffers

  398.         uint port_index;

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

  400.             fNetMidiCaptureBuffer->SetBuffer(port_index,

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

  402.                                             fParams.fPeriodSize )));

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

  404.             fNetAudioCaptureBuffer->SetBuffer(port_index,

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

  406.                                              fParams.fPeriodSize )));

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

  408.             fNetMidiPlaybackBuffer->SetBuffer(port_index,

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

  410.                                              fParams.fPeriodSize )));

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

  412.             fNetAudioPlaybackBuffer->SetBuffer(port_index,

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

  414.                                               fParams.fPeriodSize )));

  415. 

  416.         //send ------------------------------------------------------------------------------------------------------------------

  417.         //sync

  418.         fTxHeader.fDataType = 's';

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

  420.             fTxHeader.fIsLastPckt = 'y';

  421.         memset ( fTxData, 0, fPayloadSize );

  422.         SetSyncPacket();

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

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

  425.             return tx_bytes;

  426. 

  427. #ifdef JACK_MONITOR

  428.         fMeasure[1] = jack_frames_since_cycle_start( fJackClient );

  429. #endif

  430. 

  431.         //midi

  432.         if ( fParams.fSendMidiChannels )

  433.         {

  434.             fTxHeader.fDataType = 'm';

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

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

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

  438.             {

  439.                 fTxHeader.fSubCycle = subproc;

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

  441.                     fTxHeader.fIsLastPckt = 'y';

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

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

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

  445.                 if ( tx_bytes < 1 )

  446.                     return tx_bytes;

  447.             }

  448.         }

  449. 

  450.         //audio

  451.         if ( fParams.fSendAudioChannels )

  452.         {

  453.             fTxHeader.fDataType = 'a';

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

  455.             {

  456.                 fTxHeader.fSubCycle = subproc;

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

  458.                     fTxHeader.fIsLastPckt = 'y';

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

  460.                 fNetAudioCaptureBuffer->RenderFromJackPorts ( subproc );

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

  462.                 if ( tx_bytes < 1 )

  463.                     return tx_bytes;

  464.             }

  465.         }

  466. 

  467. #ifdef JACK_MONITOR

  468.         fMeasure[2] = jack_frames_since_cycle_start( fJackClient );

  469. #endif

  470. 

  471.         //receive --------------------------------------------------------------------------------------------------------------------

  472.         //sync

  473.         do

  474.         {

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

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

  477.                 return rx_bytes;

  478.         }

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

  480. 

  481. #ifdef JACK_MONITOR

  482.         fMeasure[3] = jack_frames_since_cycle_start( fJackClient );

  483. #endif

  484. 

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

  486.         {

  487.             do

  488.             {

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

  490.                     return rx_bytes;

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

  492.                 {

  493.                     switch ( rx_head->fDataType )

  494.                     {

  495.                     case 'm':	//midi

  496.                         rx_bytes = Recv ( rx_bytes, 0 );

  497.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

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

  500.                             fNetMidiPlaybackBuffer->RenderToJackPorts();

  501.                         fNetJumpCnt = 0;

  502.                         break;

  503.                     case 'a':	//audio

  504.                         rx_bytes = Recv ( fAudioRxLen, 0 );

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

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

  507.                         fRxHeader.fCycle = rx_head->fCycle;

  508.                         fRxHeader.fSubCycle = rx_head->fSubCycle;

  509.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

  511.                         fNetJumpCnt = 0;

  512.                         break;

  513.                     case 's':	//sync

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

  515.                         fRxHeader.fCycle = rx_head->fCycle;

  516.                         return 0;

  517.                     }

  518.                 }

  519.             }

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

  521.         }

  522. 

  523. #ifdef JACK_MONITOR

  524.         fMeasure[4] = jack_frames_since_cycle_start( fJackClient );

  525.         fMonitor.Write ( fMeasure );

  526. #endif

  527.         return 0;

  528.     }

  529. 

  530. //JackNetMasterManager***********************************************************************************************

  531. 

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

  533.     {

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

  535.         fManagerClient = client;

  536.         fManagerName = jack_get_client_name ( fManagerClient );

  537.         fMulticastIP = DEFAULT_MULTICAST_IP;

  538.         fSocket.SetPort ( DEFAULT_PORT );

  539.         fGlobalID = 0;

  540.         fRunning = true;

  541. 

  542.         const JSList* node;

  543.         const jack_driver_param_t* param;

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

  545.         {

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

  547.             switch ( param->character )

  548.             {

  549.             case 'a' :

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

  551.                 break;

  552.             case 'p':

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

  554.             }

  555.         }

  556. 

  557.         //set sync callback

  558.         jack_set_sync_callback ( fManagerClient, SetSyncCallback, this );

  559. 

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

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

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

  563. 

  564.         //launch the manager thread

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

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

  567.     }

  568. 

  569.     JackNetMasterManager::~JackNetMasterManager()

  570.     {

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

  572.         Exit();

  573.         master_list_t::iterator it;

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

  575.             delete ( *it );

  576.         fSocket.Close();

  577.         SocketAPIEnd();

  578.     }

  579. 

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

  581.     {

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

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

  584.     }

  585. 

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

  587.     {

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

  589.         int ret = 1;

  590.         master_list_it_t it;

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

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

  593.                 ret = 0;

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

  595.         return ret;

  596.     }

  597. 

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

  599.     {

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

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

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

  603.         master_manager->Run();

  604.         return NULL;

  605.     }

  606. 

  607.     void JackNetMasterManager::Run()

  608.     {

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

  610.         //utility variables

  611.         int msec_timeout = 2000;

  612.         int attempt = 0;

  613. 

  614.         //data

  615.         session_params_t params;

  616.         int rx_bytes = 0;

  617.         JackNetMaster* net_master;

  618. 

  619.         //init socket API (win32)

  620.         if ( SocketAPIInit() < 0 )

  621.         {

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

  623.             return;

  624.         }

  625. 

  626.         //socket

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

  628.         {

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

  630.             return;

  631.         }

  632. 

  633.         //bind the socket to the local port

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

  635.         {

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

  637.             fSocket.Close();

  638.             return;

  639.         }

  640. 

  641.         //join multicast group

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

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

  644. 

  645.         //local loop

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

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

  648. 

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

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

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

  652. 

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

  654. 

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

  656.         do

  657.         {

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

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

  660.             {

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

  662.                 if ( ++attempt == 10 )

  663.                 {

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

  665.                     return;

  666.                 }

  667.             }

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

  669.             {

  670.                 switch ( GetPacketType ( &params ) )

  671.                 {

  672.                 case SLAVE_AVAILABLE:

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

  674.                         SessionParamsDisplay ( &net_master->fParams );

  675.                     else

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

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

  678.                     break;

  679.                 case KILL_MASTER:

  680.                     KillMaster ( &params );

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

  682.                     break;

  683.                 default:

  684.                     break;

  685.                 }

  686.             }

  687.         }

  688.         while ( fRunning );

  689.     }

  690. 

  691.     void JackNetMasterManager::Exit()

  692.     {

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

  694.         fRunning = false;

  695.         jack_client_stop_thread ( fManagerClient, fManagerThread );

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

  697.     }

  698. 

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

  700.     {

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

  702.         //settings

  703.         fSocket.GetName ( params.fMasterNetName );

  704.         params.fID = ++fGlobalID;

  705.         params.fSampleRate = jack_get_sample_rate ( fManagerClient );

  706.         params.fPeriodSize = jack_get_buffer_size ( fManagerClient );

  707.         params.fBitdepth = 0;

  708.         SetFramesPerPacket ( &params );

  709.         SetSlaveName ( params );

  710. 

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

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

  713.         if ( master->Init() )

  714.         {

  715.             fMasterList.push_back ( master );

  716.             return master;

  717.         }

  718.         delete master;

  719.         return NULL;

  720.     }

  721. 

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

  723.     {

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

  725.         master_list_it_t it;

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

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

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

  729.     }

  730. 

  731.     master_list_it_t JackNetMasterManager::FindMaster ( uint32_t id )

  732.     {

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

  734.         master_list_it_t it;

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

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

  737.                 return it;

  738.         return it;

  739.     }

  740. 

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

  742.     {

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

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

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

  746.         {

  747.             fMasterList.erase ( master );

  748.             delete *master;

  749.         }

  750.     }

  751. }//namespace

  752. 

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

  754. 

  755. #ifdef __cplusplus

  756. extern "C"

  757. {

  758. #endif

  759. 

  760.     EXPORT jack_driver_desc_t* jack_get_descriptor()

  761.     {

  762.         jack_driver_desc_t *desc;

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

  764. 

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

  766.         desc->nparams = 2;

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

  768. 

  769.         int i = 0;

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

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

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

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

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

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

  776. 

  777.         i++;

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

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

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

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

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

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

  784. 

  785.         return desc;

  786.     }

  787. 

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

  789.     {

  790.         if ( master_manager )

  791.         {

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

  793.             return 1;

  794.         }

  795.         else

  796.         {

  797.             jack_log ( "Loading Master Manager" );

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

  799.             return ( master_manager ) ? 0 : 1;

  800.         }

  801.     }

  802. 

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

  804.     {

  805.         JSList* params = NULL;

  806.         jack_driver_desc_t* desc = jack_get_descriptor();

  807.         Jack::JackArgParser parser ( load_init );

  808. 

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

  810.         {

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

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

  813.         }

  814. 

  815.         return jack_internal_initialize(jack_client, params);

  816.     }

  817. 

  818.     EXPORT void jack_finish ( void* arg )

  819.     {

  820.         if ( master_manager )

  821.         {

  822.             jack_log ( "Unloading Master Manager" );

  823.             delete master_manager;

  824.             master_manager = NULL;

  825.         }

  826.     }

  827. #ifdef __cplusplus

  828. }

  829. #endif