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

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

  32.     {

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

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

  35.     };

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

  37.     {

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

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

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

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

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

  43.     };

  44. #endif

  45. 

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

  47.     {

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

  49.         //settings

  50.         fMasterManager = manager;

  51.         fParams = params;

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

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

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

  55.         fNetJumpCnt = 0;

  56.         fJackClient = NULL;

  57.         fRunning = false;

  58.         fSyncState = 1;

  59.         uint port_index;

  60. 

  61.         //jack audio ports

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

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

  64.             fAudioCapturePorts[port_index] = NULL;

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

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

  67.             fAudioPlaybackPorts[port_index] = NULL;

  68.         //jack midi ports

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

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

  71.             fMidiCapturePorts[port_index] = NULL;

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

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

  74.             fMidiPlaybackPorts[port_index] = NULL;

  75. 

  76.         //TX header init

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

  78.         fTxHeader.fDataStream = 's';

  79.         fTxHeader.fID = fParams.fID;

  80.         fTxHeader.fCycle = 0;

  81.         fTxHeader.fSubCycle = 0;

  82.         fTxHeader.fMidiDataSize = 0;

  83.         fTxHeader.fBitdepth = fParams.fBitdepth;

  84. 

  85.         //RX header init

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

  87.         fRxHeader.fDataStream = 'r';

  88.         fRxHeader.fID = fParams.fID;

  89.         fRxHeader.fCycle = 0;

  90.         fRxHeader.fSubCycle = 0;

  91.         fRxHeader.fMidiDataSize = 0;

  92.         fRxHeader.fBitdepth = fParams.fBitdepth;

  93. 

  94.         //network buffers

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

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

  97. 

  98.         //net audio buffers

  99.         fTxData = fTxBuffer + sizeof ( packet_header_t );

  100.         fRxData = fRxBuffer + sizeof ( packet_header_t );

  101. 

  102.         //midi net buffers

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

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

  105. 

  106.         //audio net buffers

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

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

  109. 

  110.         //audio netbuffer length

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

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

  113. 

  114.         //payload size

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

  116. 

  117.         //monitor

  118. #ifdef JACK_MONITOR

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

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

  121. #endif

  122.     }

  123. 

  124.     JackNetMaster::~JackNetMaster()

  125.     {

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

  127.         if ( fJackClient )

  128.         {

  129.             jack_deactivate ( fJackClient );

  130.             FreePorts();

  131.             jack_client_close ( fJackClient );

  132.         }

  133.         fSocket.Close();

  134.         delete fNetAudioCaptureBuffer;

  135.         delete fNetAudioPlaybackBuffer;

  136.         delete fNetMidiCaptureBuffer;

  137.         delete fNetMidiPlaybackBuffer;

  138.         delete[] fAudioCapturePorts;

  139.         delete[] fAudioPlaybackPorts;

  140.         delete[] fMidiCapturePorts;

  141.         delete[] fMidiPlaybackPorts;

  142.         delete[] fTxBuffer;

  143.         delete[] fRxBuffer;

  144. #ifdef JACK_MONITOR

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

  146.         fMonitor.Save ( filename );

  147. #endif

  148.     }

  149. 

  150.     bool JackNetMaster::Init()

  151.     {

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

  153.         session_params_t params;

  154.         int msec_timeout = 1000;

  155.         uint attempt = 0;

  156.         int rx_bytes = 0;

  157. 

  158.         //socket

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

  160.         {

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

  162.             return false;

  163.         }

  164. 

  165.         //timeout on receive (for init)

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

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

  168. 

  169.         //connect

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

  171.         {

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

  173.             return false;

  174.         }

  175. 

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

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

  178.         do

  179.         {

  180.             SetPacketType ( &fParams, SLAVE_SETUP );

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

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

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

  184.             {

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

  186.                 return false;

  187.             }

  188.         }

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

  190.         if ( attempt == 5 )

  191.         {

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

  193.             return false;

  194.         }

  195. 

  196.         //set the new timeout for the socket

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

  198.         {

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

  200.             return false;

  201.         }

  202. 

  203.         //jack client and process

  204.         jack_status_t status;

  205.         jack_options_t options = JackNullOption;

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

  207.         {

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

  209.             return false;

  210.         }

  211. 

  212.         jack_set_process_callback ( fJackClient, SetProcess, this );

  213. 

  214.         //port registering

  215.         uint i;

  216.         char name[24];

  217.         jack_nframes_t port_latency = jack_get_buffer_size ( fJackClient );

  218.         unsigned long port_flags;

  219.         //audio

  220.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  222.         {

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

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

  225.                 goto fail;

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

  227.         }

  228.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  230.         {

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

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

  233.                 goto fail;

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

  235.         }

  236.         //midi

  237.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  239.         {

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

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

  242.                 goto fail;

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

  244.         }

  245.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  247.         {

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

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

  250.                 goto fail;

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

  252.         }

  253. 

  254.         fRunning = true;

  255. 

  256.         //finally activate jack client

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

  258.         {

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

  260.             goto fail;

  261.         }

  262. 

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

  264. 

  265.         return true;

  266. 

  267. fail:

  268.         FreePorts();

  269.         jack_client_close ( fJackClient );

  270.         fJackClient = NULL;

  271.         return false;

  272.     }

  273. 

  274.     void JackNetMaster::FreePorts()

  275.     {

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

  277.         uint port_index;

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

  279.             if ( fAudioCapturePorts[port_index] )

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

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

  282.             if ( fAudioPlaybackPorts[port_index] )

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

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

  285.             if ( fMidiCapturePorts[port_index] )

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

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

  288.             if ( fMidiPlaybackPorts[port_index] )

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

  290.     }

  291. 

  292.     void JackNetMaster::Exit()

  293.     {

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

  295.         //stop process

  296.         fRunning = false;

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

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

  299.         SetPacketType ( &fParams, KILL_MASTER );

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

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

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

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

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

  305.         mcast_socket.Close();

  306.     }

  307. 

  308.     int JackNetMaster::SetSyncPacket()

  309.     {

  310.         if ( fParams.fTransportSync )

  311.         {

  312.             //set the TransportData

  313. 

  314.             //copy to TxBuffer

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

  316.         }

  317.         return 0;

  318.     }

  319. 

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

  321.     {

  322.         int tx_bytes;

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

  324.         {

  325.             net_error_t error = fSocket.GetError();

  326.             if ( error == NET_CONN_ERROR )

  327.             {

  328.                 //fatal connection issue, exit

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

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

  331.                 Exit();

  332.                 return 0;

  333.             }

  334.             else

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

  336.         }

  337.         return tx_bytes;

  338.     }

  339. 

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

  341.     {

  342.         int rx_bytes;

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

  344.         {

  345.             net_error_t error = fSocket.GetError();

  346.             if ( error == NET_NO_DATA )

  347.             {

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

  349.                 if ( ++fNetJumpCnt == 50 )

  350.                 {

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

  352.                     fNetJumpCnt = 0;

  353.                 }

  354.                 return 0;

  355.             }

  356.             else if ( error == NET_CONN_ERROR )

  357.             {

  358.                 //fatal connection issue, exit

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

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

  361.                 Exit();

  362.                 return 0;

  363.             }

  364.             else

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

  366.         }

  367.         return rx_bytes;

  368.     }

  369. 

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

  371.     {

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

  373.         return master->Process();

  374.     }

  375. 

  376.     int JackNetMaster::Process()

  377.     {

  378.         if ( !fRunning )

  379.             return 0;

  380. 

  381.         int tx_bytes, rx_bytes, copy_size;

  382.         size_t midi_recvd_pckt = 0;

  383.         fTxHeader.fCycle++;

  384.         fTxHeader.fSubCycle = 0;

  385.         fTxHeader.fIsLastPckt = 'n';

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

  387. 

  388. #ifdef JACK_MONITOR

  389.         NetMeasure<jack_nframes_t> measure;

  390.         measure.fTable[0] = jack_frames_since_cycle_start( fJackClient );

  391. #endif

  392. 

  393.         //buffers

  394.         uint port_index;

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

  396.             fNetMidiCaptureBuffer->SetBuffer(port_index,

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

  398.                                             fParams.fPeriodSize )));

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

  400.             fNetAudioCaptureBuffer->SetBuffer(port_index,

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

  402.                                              fParams.fPeriodSize )));

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

  404.             fNetMidiPlaybackBuffer->SetBuffer(port_index,

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

  406.                                              fParams.fPeriodSize )));

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

  408.             fNetAudioPlaybackBuffer->SetBuffer(port_index,

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

  410.                                               fParams.fPeriodSize )));

  411. 

  412.         //send ------------------------------------------------------------------------------------------------------------------

  413.         //sync

  414.         fTxHeader.fDataType = 's';

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

  416.             fTxHeader.fIsLastPckt = 'y';

  417.         memset ( fTxData, 0, fPayloadSize );

  418.         SetSyncPacket();

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

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

  421.             return tx_bytes;

  422. 

  423. #ifdef JACK_MONITOR

  424.         measure.fTable[1] = jack_frames_since_cycle_start( fJackClient );

  425. #endif

  426. 

  427.         //midi

  428.         if ( fParams.fSendMidiChannels )

  429.         {

  430.             fTxHeader.fDataType = 'm';

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

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

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

  434.             {

  435.                 fTxHeader.fSubCycle = subproc;

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

  437.                     fTxHeader.fIsLastPckt = 'y';

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

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

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

  441.                 if ( tx_bytes < 1 )

  442.                     return tx_bytes;

  443.             }

  444.         }

  445. 

  446.         //audio

  447.         if ( fParams.fSendAudioChannels )

  448.         {

  449.             fTxHeader.fDataType = 'a';

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

  451.             {

  452.                 fTxHeader.fSubCycle = subproc;

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

  454.                     fTxHeader.fIsLastPckt = 'y';

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

  456.                 fNetAudioCaptureBuffer->RenderFromJackPorts ( subproc );

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

  458.                 if ( tx_bytes < 1 )

  459.                     return tx_bytes;

  460.             }

  461.         }

  462. 

  463. #ifdef JACK_MONITOR

  464.         measure.fTable[2] = jack_frames_since_cycle_start( fJackClient );

  465. #endif

  466. 

  467.         //receive --------------------------------------------------------------------------------------------------------------------

  468.         //sync

  469.         do

  470.         {

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

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

  473.                 return rx_bytes;

  474.         }

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

  476. 

  477. #ifdef JACK_MONITOR

  478.         measure.fTable[3] = jack_frames_since_cycle_start( fJackClient );

  479. #endif

  480. 

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

  482.         {

  483.             do

  484.             {

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

  486.                     return rx_bytes;

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

  488.                 {

  489.                     switch ( rx_head->fDataType )

  490.                     {

  491.                     case 'm':	//midi

  492.                         rx_bytes = Recv ( rx_bytes, 0 );

  493.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

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

  496.                             fNetMidiPlaybackBuffer->RenderToJackPorts();

  497.                         fNetJumpCnt = 0;

  498.                         break;

  499.                     case 'a':	//audio

  500.                         rx_bytes = Recv ( fAudioRxLen, 0 );

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

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

  503.                         fRxHeader.fCycle = rx_head->fCycle;

  504.                         fRxHeader.fSubCycle = rx_head->fSubCycle;

  505.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

  507.                         fNetJumpCnt = 0;

  508.                         break;

  509.                     case 's':	//sync

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

  511.                         fRxHeader.fCycle = rx_head->fCycle;

  512.                         return 0;

  513.                     }

  514.                 }

  515.             }

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

  517.         }

  518. 

  519. #ifdef JACK_MONITOR

  520.         measure.fTable[4] = jack_frames_since_cycle_start( fJackClient );

  521.         fMonitor.Write ( measure );

  522. #endif

  523.         return 0;

  524.     }

  525. 

  526. //JackNetMasterManager***********************************************************************************************

  527. 

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

  529.     {

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

  531.         fManagerClient = client;

  532.         fManagerName = jack_get_client_name ( fManagerClient );

  533.         fMulticastIP = DEFAULT_MULTICAST_IP;

  534.         fSocket.SetPort ( DEFAULT_PORT );

  535.         fGlobalID = 0;

  536.         fRunning = true;

  537. 

  538.         const JSList* node;

  539.         const jack_driver_param_t* param;

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

  541.         {

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

  543.             switch ( param->character )

  544.             {

  545.             case 'a' :

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

  547.                 break;

  548.             case 'p':

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

  550.             }

  551.         }

  552. 

  553.         //set sync callback

  554.         jack_set_sync_callback ( fManagerClient, SetSyncCallback, this );

  555. 

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

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

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

  559. 

  560.         //launch the manager thread

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

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

  563.     }

  564. 

  565.     JackNetMasterManager::~JackNetMasterManager()

  566.     {

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

  568.         Exit();

  569.         master_list_t::iterator it;

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

  571.             delete ( *it );

  572.         fSocket.Close();

  573.         SocketAPIEnd();

  574.     }

  575. 

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

  577.     {

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

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

  580.     }

  581. 

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

  583.     {

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

  585.         int ret = 1;

  586.         master_list_it_t it;

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

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

  589.                 ret = 0;

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

  591.         return ret;

  592.     }

  593. 

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

  595.     {

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

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

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

  599.         master_manager->Run();

  600.         return NULL;

  601.     }

  602. 

  603.     void JackNetMasterManager::Run()

  604.     {

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

  606.         //utility variables

  607.         int msec_timeout = 2000;

  608.         int attempt = 0;

  609. 

  610.         //data

  611.         session_params_t params;

  612.         int rx_bytes = 0;

  613.         JackNetMaster* net_master;

  614. 

  615.         //init socket API (win32)

  616.         if ( SocketAPIInit() < 0 )

  617.         {

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

  619.             return;

  620.         }

  621. 

  622.         //socket

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

  624.         {

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

  626.             return;

  627.         }

  628. 

  629.         //bind the socket to the local port

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

  631.         {

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

  633.             fSocket.Close();

  634.             return;

  635.         }

  636. 

  637.         //join multicast group

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

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

  640. 

  641.         //local loop

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

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

  644. 

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

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

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

  648. 

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

  650. 

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

  652.         do

  653.         {

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

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

  656.             {

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

  658.                 if ( ++attempt == 10 )

  659.                 {

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

  661.                     return;

  662.                 }

  663.             }

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

  665.             {

  666.                 switch ( GetPacketType ( &params ) )

  667.                 {

  668.                 case SLAVE_AVAILABLE:

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

  670.                         SessionParamsDisplay ( &net_master->fParams );

  671.                     else

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

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

  674.                     break;

  675.                 case KILL_MASTER:

  676.                     KillMaster ( &params );

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

  678.                     break;

  679.                 default:

  680.                     break;

  681.                 }

  682.             }

  683.         }

  684.         while ( fRunning );

  685.     }

  686. 

  687.     void JackNetMasterManager::Exit()

  688.     {

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

  690.         fRunning = false;

  691.         jack_client_stop_thread ( fManagerClient, fManagerThread );

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

  693.     }

  694. 

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

  696.     {

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

  698.         //settings

  699.         fSocket.GetName ( params.fMasterNetName );

  700.         params.fID = ++fGlobalID;

  701.         params.fSampleRate = jack_get_sample_rate ( fManagerClient );

  702.         params.fPeriodSize = jack_get_buffer_size ( fManagerClient );

  703.         params.fBitdepth = 0;

  704.         SetFramesPerPacket ( &params );

  705.         SetSlaveName ( params );

  706. 

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

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

  709.         if ( master->Init() )

  710.         {

  711.             fMasterList.push_back ( master );

  712.             return master;

  713.         }

  714.         delete master;

  715.         return NULL;

  716.     }

  717. 

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

  719.     {

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

  721.         master_list_it_t it;

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

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

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

  725.     }

  726. 

  727.     master_list_it_t JackNetMasterManager::FindMaster ( uint32_t id )

  728.     {

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

  730.         master_list_it_t it;

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

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

  733.                 return it;

  734.         return it;

  735.     }

  736. 

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

  738.     {

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

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

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

  742.         {

  743.             fMasterList.erase ( master );

  744.             delete *master;

  745.         }

  746.     }

  747. }//namespace

  748. 

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

  750. 

  751. #ifdef __cplusplus

  752. extern "C"

  753. {

  754. #endif

  755. 

  756.     EXPORT jack_driver_desc_t* jack_get_descriptor()

  757.     {

  758.         jack_driver_desc_t *desc;

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

  760. 

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

  762.         desc->nparams = 2;

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

  764. 

  765.         int i = 0;

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

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

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

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

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

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

  772. 

  773.         i++;

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

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

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

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

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

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

  780. 

  781.         return desc;

  782.     }

  783. 

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

  785.     {

  786.         if ( master_manager )

  787.         {

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

  789.             return 1;

  790.         }

  791.         else

  792.         {

  793.             jack_log ( "Loading Master Manager" );

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

  795.             return ( master_manager ) ? 0 : 1;

  796.         }

  797.     }

  798. 

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

  800.     {

  801.         JSList* params = NULL;

  802.         jack_driver_desc_t* desc = jack_get_descriptor();

  803.         Jack::JackArgParser parser ( load_init );

  804. 

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

  806.         {

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

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

  809.         }

  810. 

  811.         return jack_internal_initialize(jack_client, params);

  812.     }

  813. 

  814.     EXPORT void jack_finish ( void* arg )

  815.     {

  816.         if ( master_manager )

  817.         {

  818.             jack_log ( "Unloading Master Manager" );

  819.             delete master_manager;

  820.             master_manager = NULL;

  821.         }

  822.     }

  823. #ifdef __cplusplus

  824. }

  825. #endif