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

846 lines
33KB
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. #if defined(HAVE_CONFIG_H)

  21. #include "config.h"

  22. #endif

  23. 

  24. #include "JackNetManager.h"

  25. 

  26. #define DEFAULT_MULTICAST_IP "225.3.19.154"

  27. #define DEFAULT_PORT 19000

  28. 

  29. using namespace std;

  30. 

  31. namespace Jack

  32. {

  33. //JackNetMaster******************************************************************************************************

  34. #ifdef JACK_MONITOR

  35.     uint JackNetMaster::fMeasureCnt = 128;

  36.     uint JackNetMaster::fMeasurePoints = 4;

  37.     string JackNetMaster::fMonitorFieldNames[] =

  38.     {

  39.         string ( "sync send" ),

  40.         string ( "end of send" ),

  41.         string ( "sync recv" ),

  42.         string ( "end of cycle" )

  43.     };

  44.     uint JackNetMaster::fMonitorPlotOptionsCnt = 2;

  45.     string JackNetMaster::fMonitorPlotOptions[] =

  46.     {

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

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

  49.     };

  50. #endif

  51. 

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

  53.     {

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

  55.         //settings

  56.         fMasterManager = manager;

  57.         fParams = params;

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

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

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

  61.         fNetJumpCnt = 0;

  62.         fJackClient = NULL;

  63.         fRunning = false;

  64.         fSyncState = 1;

  65.         uint port_index;

  66. 

  67.         //jack audio ports

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

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

  70.             fAudioCapturePorts[port_index] = NULL;

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

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

  73.             fAudioPlaybackPorts[port_index] = NULL;

  74.         //jack midi ports

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

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

  77.             fMidiCapturePorts[port_index] = NULL;

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

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

  80.             fMidiPlaybackPorts[port_index] = NULL;

  81. 

  82.         //TX header init

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

  84.         fTxHeader.fDataStream = 's';

  85.         fTxHeader.fID = fParams.fID;

  86.         fTxHeader.fCycle = 0;

  87.         fTxHeader.fSubCycle = 0;

  88.         fTxHeader.fMidiDataSize = 0;

  89.         fTxHeader.fBitdepth = fParams.fBitdepth;

  90. 

  91.         //RX header init

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

  93.         fRxHeader.fDataStream = 'r';

  94.         fRxHeader.fID = fParams.fID;

  95.         fRxHeader.fCycle = 0;

  96.         fRxHeader.fSubCycle = 0;

  97.         fRxHeader.fMidiDataSize = 0;

  98.         fRxHeader.fBitdepth = fParams.fBitdepth;

  99. 

  100.         //network buffers

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

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

  103. 

  104.         //net audio buffers

  105.         fTxData = fTxBuffer + sizeof ( packet_header_t );

  106.         fRxData = fRxBuffer + sizeof ( packet_header_t );

  107. 

  108.         //midi net buffers

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

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

  111. 

  112.         //audio net buffers

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

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

  115. 

  116.         //audio netbuffer length

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

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

  119. 

  120.         //payload size

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

  122. 

  123.         //monitor

  124. #ifdef JACK_MONITOR

  125.         fPeriodUsecs = ( int ) ( 1000000.f * ( ( float ) fParams.fPeriodSize / ( float ) fParams.fSampleRate ) );

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

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

  128.         plot_name += string ( ( fParams.fSlaveSyncMode ) ? "_sync" : "_async" );

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

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

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

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

  133. #endif

  134.     }

  135. 

  136.     JackNetMaster::~JackNetMaster()

  137.     {

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

  139.         if ( fJackClient )

  140.         {

  141.             jack_deactivate ( fJackClient );

  142.             FreePorts();

  143.             jack_client_close ( fJackClient );

  144.         }

  145.         fSocket.Close();

  146.         delete fNetAudioCaptureBuffer;

  147.         delete fNetAudioPlaybackBuffer;

  148.         delete fNetMidiCaptureBuffer;

  149.         delete fNetMidiPlaybackBuffer;

  150.         delete[] fAudioCapturePorts;

  151.         delete[] fAudioPlaybackPorts;

  152.         delete[] fMidiCapturePorts;

  153.         delete[] fMidiPlaybackPorts;

  154.         delete[] fTxBuffer;

  155.         delete[] fRxBuffer;

  156. #ifdef JACK_MONITOR

  157.         fMonitor->Save();

  158.         delete[] fMeasure;

  159.         delete fMonitor;

  160. #endif

  161.     }

  162. 

  163.     bool JackNetMaster::Init()

  164.     {

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

  166.         session_params_t params;

  167.         int msec_timeout = 1000;

  168.         uint attempt = 0;

  169.         int rx_bytes = 0;

  170. 

  171.         //socket

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

  173.         {

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

  175.             return false;

  176.         }

  177. 

  178.         //timeout on receive (for init)

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

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

  181. 

  182.         //connect

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

  184.         {

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

  186.             return false;

  187.         }

  188. 

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

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

  191.         do

  192.         {

  193.             SetPacketType ( &fParams, SLAVE_SETUP );

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

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

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

  197.             {

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

  199.                 return false;

  200.             }

  201.         }

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

  203.         if ( attempt == 5 )

  204.         {

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

  206.             return false;

  207.         }

  208. 

  209.         //set the new timeout for the socket

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

  211.         {

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

  213.             return false;

  214.         }

  215. 

  216.         //jack client and process

  217.         jack_status_t status;

  218.         jack_options_t options = JackNullOption;

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

  220.         {

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

  222.             return false;

  223.         }

  224. 

  225.         jack_set_process_callback ( fJackClient, SetProcess, this );

  226. 

  227.         //port registering

  228.         uint i;

  229.         char name[24];

  230.         jack_nframes_t port_latency = jack_get_buffer_size ( fJackClient );

  231.         unsigned long port_flags;

  232.         //audio

  233.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  235.         {

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

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

  238.                 goto fail;

  239.             jack_port_set_latency ( fAudioCapturePorts[i], 0 );

  240.         }

  241.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  243.         {

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

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

  246.                 goto fail;

  247.             jack_port_set_latency ( fAudioPlaybackPorts[i], port_latency + ( fParams.fSlaveSyncMode ) ? 0 : port_latency );

  248.         }

  249.         //midi

  250.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  252.         {

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

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

  255.                 goto fail;

  256.             jack_port_set_latency ( fMidiCapturePorts[i], 0 );

  257.         }

  258.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  260.         {

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

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

  263.                 goto fail;

  264.             jack_port_set_latency ( fMidiPlaybackPorts[i], port_latency + ( fParams.fSlaveSyncMode ) ? 0 : port_latency );

  265.         }

  266. 

  267.         fRunning = true;

  268. 

  269.         //finally activate jack client

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

  271.         {

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

  273.             goto fail;

  274.         }

  275. 

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

  277. 

  278.         return true;

  279. 

  280.     fail:

  281.         FreePorts();

  282.         jack_client_close ( fJackClient );

  283.         fJackClient = NULL;

  284.         return false;

  285.     }

  286. 

  287.     void JackNetMaster::FreePorts()

  288.     {

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

  290.         uint port_index;

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

  292.             if ( fAudioCapturePorts[port_index] )

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

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

  295.             if ( fAudioPlaybackPorts[port_index] )

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

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

  298.             if ( fMidiCapturePorts[port_index] )

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

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

  301.             if ( fMidiPlaybackPorts[port_index] )

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

  303.     }

  304. 

  305.     void JackNetMaster::Exit()

  306.     {

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

  308.         //stop process

  309.         fRunning = false;

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

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

  312.         SetPacketType ( &fParams, KILL_MASTER );

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

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

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

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

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

  318.         mcast_socket.Close();

  319.     }

  320. 

  321.     int JackNetMaster::SetSyncPacket()

  322.     {

  323.         if ( fParams.fTransportSync )

  324.         {

  325.             //set the TransportData

  326. 

  327.             //copy to TxBuffer

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

  329.         }

  330.         return 0;

  331.     }

  332. 

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

  334.     {

  335.         int tx_bytes;

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

  337.         {

  338.             net_error_t error = fSocket.GetError();

  339.             if ( error == NET_CONN_ERROR )

  340.             {

  341.                 //fatal connection issue, exit

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

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

  344.                 Exit();

  345.             }

  346.             else

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

  348.         }

  349.         return tx_bytes;

  350.     }

  351. 

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

  353.     {

  354.         int rx_bytes;

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

  356.         {

  357.             net_error_t error = fSocket.GetError();

  358.             if ( error == NET_NO_DATA )

  359.             {

  360.                 //too much receive failure, react

  361.                 if ( ++fNetJumpCnt < 100 )

  362.                     return 0;

  363.                 else

  364.                 {

  365.                     jack_error ( "No data from %s...", fParams.fName );

  366.                     fNetJumpCnt = 0;

  367.                 }

  368.             }

  369.             else if ( error == NET_CONN_ERROR )

  370.             {

  371.                 //fatal connection issue, exit

  372.                 jack_error ( "'%s' : %s, network connection with '%s' broken, exiting.",

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

  374.                 //ask to the manager to properly remove the master

  375.                 Exit();

  376.             }

  377.             else

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

  379.         }

  380.         return rx_bytes;

  381.     }

  382. 

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

  384.     {

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

  386.         return master->Process();

  387.     }

  388. 

  389.     int JackNetMaster::Process()

  390.     {

  391.         if ( !fRunning )

  392.             return 0;

  393. 

  394.         int tx_bytes, rx_bytes, copy_size;

  395.         size_t midi_recvd_pckt = 0;

  396.         fTxHeader.fCycle++;

  397.         fTxHeader.fSubCycle = 0;

  398.         fTxHeader.fIsLastPckt = 'n';

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

  400. 

  401. #ifdef JACK_MONITOR

  402.         jack_time_t begin_time = jack_get_time();

  403.         fMeasureId = 0;

  404. #endif

  405. 

  406.         //buffers

  407.         uint port_index;

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

  409.             fNetMidiCaptureBuffer->SetBuffer ( port_index,

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

  411.                                                                               fParams.fPeriodSize ) ) );

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

  413.             fNetAudioCaptureBuffer->SetBuffer ( port_index,

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

  415.                                                                          fParams.fPeriodSize ) ) );

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

  417.             fNetMidiPlaybackBuffer->SetBuffer ( port_index,

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

  419.                                                                                fParams.fPeriodSize ) ) );

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

  421.             fNetAudioPlaybackBuffer->SetBuffer ( port_index,

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

  423.                                                                           fParams.fPeriodSize ) ) );

  424. 

  425.         //send ------------------------------------------------------------------------------------------------------------------

  426.         //sync

  427.         fTxHeader.fDataType = 's';

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

  429.             fTxHeader.fIsLastPckt = 'y';

  430.         memset ( fTxData, 0, fPayloadSize );

  431.         SetSyncPacket();

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

  433.         if ( tx_bytes == SOCKET_ERROR )

  434.             return tx_bytes;

  435. 

  436. #ifdef JACK_MONITOR

  437.         fMeasure[fMeasureId++] = ( ( ( float ) ( jack_get_time() - begin_time ) ) / ( float ) fPeriodUsecs ) * 100.f;

  438. #endif

  439. 

  440.         //midi

  441.         if ( fParams.fSendMidiChannels )

  442.         {

  443.             fTxHeader.fDataType = 'm';

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

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

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

  447.             {

  448.                 fTxHeader.fSubCycle = subproc;

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

  450.                     fTxHeader.fIsLastPckt = 'y';

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

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

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

  454.                 if ( tx_bytes == SOCKET_ERROR )

  455.                     return tx_bytes;

  456.             }

  457.         }

  458. 

  459.         //audio

  460.         if ( fParams.fSendAudioChannels )

  461.         {

  462.             fTxHeader.fDataType = 'a';

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

  464.             {

  465.                 fTxHeader.fSubCycle = subproc;

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

  467.                     fTxHeader.fIsLastPckt = 'y';

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

  469.                 fNetAudioCaptureBuffer->RenderFromJackPorts ( subproc );

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

  471.                 if ( tx_bytes == SOCKET_ERROR )

  472.                     return tx_bytes;

  473.             }

  474.         }

  475. 

  476. #ifdef JACK_MONITOR

  477.         fMeasure[fMeasureId++] = ( ( ( float ) ( jack_get_time() - begin_time ) ) / ( float ) fPeriodUsecs ) * 100.f;

  478. #endif

  479. 

  480.         //receive --------------------------------------------------------------------------------------------------------------------

  481.         //sync

  482.         do

  483.         {

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

  485.             if ( rx_bytes == SOCKET_ERROR )

  486.                 return rx_bytes;

  487.         }

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

  489. 

  490. #ifdef JACK_MONITOR

  491.         fMeasure[fMeasureId++] = ( ( ( float ) ( jack_get_time() - begin_time ) ) / ( float ) fPeriodUsecs ) * 100.f;

  492. #endif

  493. 

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

  495.         {

  496.             do

  497.             {

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

  499.                     return rx_bytes;

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

  501.                 {

  502.                     switch ( rx_head->fDataType )

  503.                     {

  504.                         case 'm':   //midi

  505.                             rx_bytes = Recv ( rx_bytes, 0 );

  506.                             fRxHeader.fCycle = rx_head->fCycle;

  507.                             fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

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

  510.                                 fNetMidiPlaybackBuffer->RenderToJackPorts();

  511.                             fNetJumpCnt = 0;

  512.                             break;

  513.                         case 'a':   //audio

  514.                             rx_bytes = Recv ( fAudioRxLen, 0 );

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

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

  517.                             fRxHeader.fCycle = rx_head->fCycle;

  518.                             fRxHeader.fSubCycle = rx_head->fSubCycle;

  519.                             fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

  521.                             fNetJumpCnt = 0;

  522.                             break;

  523.                         case 's':   //sync

  524.                             rx_bytes = Recv ( rx_bytes, 0 );

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

  526.                             return 0;

  527.                     }

  528.                 }

  529.             }

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

  531.         }

  532. 

  533. #ifdef JACK_MONITOR

  534.         fMeasure[fMeasureId++] = ( ( ( float ) ( jack_get_time() - begin_time ) ) / ( float ) fPeriodUsecs ) * 100.f;

  535.         fMonitor->Write ( fMeasure );

  536.         if ( fParams.fSlaveSyncMode && ( fTxHeader.fCycle - fRxHeader.fCycle ) )

  537.             jack_log ( "Monitor::SyncModeCycleOffset %d", fTxHeader.fCycle - fRxHeader.fCycle );

  538.         else if ( !fParams.fSlaveSyncMode && ( ( fTxHeader.fCycle - fRxHeader.fCycle ) != 1 ) )

  539.             jack_log ( "Monitor::ASyncModeCycleOffset %d", fTxHeader.fCycle - fRxHeader.fCycle );

  540. #endif

  541.         return 0;

  542.     }

  543. 

  544. //JackNetMasterManager***********************************************************************************************

  545. 

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

  547.     {

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

  549.         fManagerClient = client;

  550.         fManagerName = jack_get_client_name ( fManagerClient );

  551.         fMulticastIP = DEFAULT_MULTICAST_IP;

  552.         fSocket.SetPort ( DEFAULT_PORT );

  553.         fGlobalID = 0;

  554.         fRunning = true;

  555. 

  556.         const JSList* node;

  557.         const jack_driver_param_t* param;

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

  559.         {

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

  561.             switch ( param->character )

  562.             {

  563.                 case 'a' :

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

  565.                     break;

  566.                 case 'p':

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

  568.             }

  569.         }

  570. 

  571.         //set sync callback

  572.         jack_set_sync_callback ( fManagerClient, SetSyncCallback, this );

  573. 

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

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

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

  577. 

  578.         //launch the manager thread

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

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

  581.     }

  582. 

  583.     JackNetMasterManager::~JackNetMasterManager()

  584.     {

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

  586.         Exit();

  587.         master_list_t::iterator it;

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

  589.             delete ( *it );

  590.         fSocket.Close();

  591.         SocketAPIEnd();

  592.     }

  593. 

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

  595.     {

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

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

  598.     }

  599. 

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

  601.     {

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

  603.         int ret = 1;

  604.         master_list_it_t it;

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

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

  607.                 ret = 0;

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

  609.         return ret;

  610.     }

  611. 

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

  613.     {

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

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

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

  617.         master_manager->Run();

  618.         return NULL;

  619.     }

  620. 

  621.     void JackNetMasterManager::Run()

  622.     {

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

  624.         //utility variables

  625.         int msec_timeout = 2000;

  626.         int attempt = 0;

  627. 

  628.         //data

  629.         session_params_t params;

  630.         int rx_bytes = 0;

  631.         JackNetMaster* net_master;

  632. 

  633.         //init socket API (win32)

  634.         if ( SocketAPIInit() < 0 )

  635.         {

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

  637.             return;

  638.         }

  639. 

  640.         //socket

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

  642.         {

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

  644.             return;

  645.         }

  646. 

  647.         //bind the socket to the local port

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

  649.         {

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

  651.             fSocket.Close();

  652.             return;

  653.         }

  654. 

  655.         //join multicast group

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

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

  658. 

  659.         //local loop

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

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

  662. 

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

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

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

  666. 

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

  668. 

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

  670.         do

  671.         {

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

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

  674.             {

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

  676.                 if ( ++attempt == 10 )

  677.                 {

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

  679.                     return;

  680.                 }

  681.             }

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

  683.             {

  684.                 switch ( GetPacketType ( &params ) )

  685.                 {

  686.                     case SLAVE_AVAILABLE:

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

  688.                             SessionParamsDisplay ( &net_master->fParams );

  689.                         else

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

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

  692.                         break;

  693.                     case KILL_MASTER:

  694.                         if ( KillMaster ( &params ) )

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

  696.                         break;

  697.                     default:

  698.                         break;

  699.                 }

  700.             }

  701.         }

  702.         while ( fRunning );

  703.     }

  704. 

  705.     void JackNetMasterManager::Exit()

  706.     {

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

  708.         fRunning = false;

  709.         jack_client_stop_thread ( fManagerClient, fManagerThread );

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

  711.     }

  712. 

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

  714.     {

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

  716.         //settings

  717.         fSocket.GetName ( params.fMasterNetName );

  718.         params.fID = ++fGlobalID;

  719.         params.fSampleRate = jack_get_sample_rate ( fManagerClient );

  720.         params.fPeriodSize = jack_get_buffer_size ( fManagerClient );

  721.         params.fBitdepth = 0;

  722.         SetFramesPerPacket ( &params );

  723.         SetSlaveName ( params );

  724. 

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

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

  727.         if ( master->Init() )

  728.         {

  729.             fMasterList.push_back ( master );

  730.             return master;

  731.         }

  732.         delete master;

  733.         return NULL;

  734.     }

  735. 

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

  737.     {

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

  739.         master_list_it_t it;

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

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

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

  743.     }

  744. 

  745.     master_list_it_t JackNetMasterManager::FindMaster ( uint32_t id )

  746.     {

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

  748.         master_list_it_t it;

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

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

  751.                 return it;

  752.         return it;

  753.     }

  754. 

  755.     int JackNetMasterManager::KillMaster ( session_params_t* params )

  756.     {

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

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

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

  760.         {

  761.             fMasterList.erase ( master );

  762.             delete *master;

  763.             return 1;

  764.         }

  765.         return 0;

  766.     }

  767. }//namespace

  768. 

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

  770. 

  771. #ifdef __cplusplus

  772. extern "C"

  773. {

  774. #endif

  775. 

  776.     EXPORT jack_driver_desc_t* jack_get_descriptor()

  777.     {

  778.         jack_driver_desc_t *desc;

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

  780. 

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

  782.         desc->nparams = 2;

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

  784. 

  785.         int i = 0;

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

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

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

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

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

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

  792. 

  793.         i++;

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

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

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

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

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

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

  800. 

  801.         return desc;

  802.     }

  803. 

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

  805.     {

  806.         if ( master_manager )

  807.         {

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

  809.             return 1;

  810.         }

  811.         else

  812.         {

  813.             jack_log ( "Loading Master Manager" );

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

  815.             return ( master_manager ) ? 0 : 1;

  816.         }

  817.     }

  818. 

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

  820.     {

  821.         JSList* params = NULL;

  822.         jack_driver_desc_t* desc = jack_get_descriptor();

  823.         Jack::JackArgParser parser ( load_init );

  824. 

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

  826.         {

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

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

  829.         }

  830. 

  831.         return jack_internal_initialize ( jack_client, params );

  832.     }

  833. 

  834.     EXPORT void jack_finish ( void* arg )

  835.     {

  836.         if ( master_manager )

  837.         {

  838.             jack_log ( "Unloading Master Manager" );

  839.             delete master_manager;

  840.             master_manager = NULL;

  841.         }

  842.     }

  843. #ifdef __cplusplus

  844. }

  845. #endif