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

878 lines
34KB
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.         fJackClient = NULL;

  62.         fRunning = false;

  63.         fSyncState = 1;

  64.         uint port_index;

  65. 

  66.         //jack audio ports

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

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

  69.             fAudioCapturePorts[port_index] = NULL;

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

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

  72.             fAudioPlaybackPorts[port_index] = NULL;

  73.         //jack midi ports

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

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

  76.             fMidiCapturePorts[port_index] = NULL;

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

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

  79.             fMidiPlaybackPorts[port_index] = NULL;

  80. 

  81.         //TX header init

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

  83.         fTxHeader.fDataStream = 's';

  84.         fTxHeader.fID = fParams.fID;

  85.         fTxHeader.fCycle = 0;

  86.         fTxHeader.fSubCycle = 0;

  87.         fTxHeader.fMidiDataSize = 0;

  88.         fTxHeader.fBitdepth = fParams.fBitdepth;

  89. 

  90.         //RX header init

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

  92.         fRxHeader.fDataStream = 'r';

  93.         fRxHeader.fID = fParams.fID;

  94.         fRxHeader.fCycle = 0;

  95.         fRxHeader.fSubCycle = 0;

  96.         fRxHeader.fMidiDataSize = 0;

  97.         fRxHeader.fBitdepth = fParams.fBitdepth;

  98. 

  99.         //network buffers

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

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

  102. 

  103.         //net audio buffers

  104.         fTxData = fTxBuffer + sizeof ( packet_header_t );

  105.         fRxData = fRxBuffer + sizeof ( packet_header_t );

  106. 

  107.         //midi net buffers

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

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

  110. 

  111.         //audio net buffers

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

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

  114. 

  115.         //audio netbuffer length

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

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

  118. 

  119.         //payload size

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

  121. 

  122.         //monitor

  123. #ifdef JACK_MONITOR

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

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

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

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

  128.         plot_name += ( fParams.fNetworkMasterMode == 'f' ) ? string ( "_fast-network" ) : string ( "_slow-network" );

  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 usec_timeout = 1000000;

  168.         uint attempt = 0;

  169.         int rx_bytes = 0;

  170.         int rx_bufsize = 0;

  171. 

  172.         //socket

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

  174.         {

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

  176.             return false;

  177.         }

  178. 

  179.         //timeout on receive (for init)

  180.         if ( fSocket.SetTimeOut ( usec_timeout ) < 0 )

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

  182. 

  183.         //connect

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

  185.         {

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

  187.             return false;

  188.         }

  189. 

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

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

  192.         do

  193.         {

  194.             SetPacketType ( &fParams, SLAVE_SETUP );

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

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

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

  198.             {

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

  200.                 return false;

  201.             }

  202.         }

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

  204.         if ( attempt == 5 )

  205.         {

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

  207.             return false;

  208.         }

  209. 

  210.         //set the new timeout for the socket

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

  212.         {

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

  214.             return false;

  215.         }

  216. 

  217.         //set the new rx buffer size

  218.         rx_bufsize = GetNetBufferSize ( &fParams );

  219.         if ( fSocket.SetOption ( SOL_SOCKET, SO_RCVBUF, &rx_bufsize, sizeof ( rx_bufsize ) ) == SOCKET_ERROR )

  220.         {

  221.             jack_error ( "Can't set rx buffer size : %s", StrError ( NET_ERROR_CODE ) );

  222.             return false;

  223.         }

  224. 

  225.         //jack client and process

  226.         jack_status_t status;

  227.         jack_options_t options = JackNullOption;

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

  229.         {

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

  231.             return false;

  232.         }

  233. 

  234.         jack_set_process_callback ( fJackClient, SetProcess, this );

  235. 

  236.         //port registering

  237.         uint i;

  238.         char name[24];

  239.         jack_nframes_t port_latency = jack_get_buffer_size ( fJackClient );

  240.         unsigned long port_flags;

  241.         //audio

  242.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  244.         {

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

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

  247.                 goto fail;

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

  249.         }

  250.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  252.         {

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

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

  255.                 goto fail;

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

  257.         }

  258.         //midi

  259.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  261.         {

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

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

  264.                 goto fail;

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

  266.         }

  267.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  269.         {

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

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

  272.                 goto fail;

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

  274.         }

  275. 

  276.         fRunning = true;

  277. 

  278.         //finally activate jack client

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

  280.         {

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

  282.             goto fail;

  283.         }

  284. 

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

  286. 

  287.         return true;

  288. 

  289.     fail:

  290.         FreePorts();

  291.         jack_client_close ( fJackClient );

  292.         fJackClient = NULL;

  293.         return false;

  294.     }

  295. 

  296.     void JackNetMaster::FreePorts()

  297.     {

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

  299.         uint port_index;

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

  301.             if ( fAudioCapturePorts[port_index] )

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

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

  304.             if ( fAudioPlaybackPorts[port_index] )

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

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

  307.             if ( fMidiCapturePorts[port_index] )

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

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

  310.             if ( fMidiPlaybackPorts[port_index] )

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

  312.     }

  313. 

  314.     void JackNetMaster::Exit()

  315.     {

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

  317.         //stop process

  318.         fRunning = false;

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

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

  321.         SetPacketType ( &fParams, KILL_MASTER );

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

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

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

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

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

  327.         mcast_socket.Close();

  328.     }

  329. 

  330.     int JackNetMaster::SetSyncPacket()

  331.     {

  332.         if ( fParams.fTransportSync )

  333.         {

  334.             //TODO : set the TransportData

  335. 

  336.             //copy to TxBuffer

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

  338.         }

  339.         return 0;

  340.     }

  341. 

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

  343.     {

  344.         int tx_bytes;

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

  346.         {

  347.             net_error_t error = fSocket.GetError();

  348.             if ( fRunning && ( error == NET_CONN_ERROR ) )

  349.             {

  350.                 //fatal connection issue, exit

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

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

  353.                 Exit();

  354.             }

  355.             else if ( fRunning )

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

  357.         }

  358.         return tx_bytes;

  359.     }

  360. 

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

  362.     {

  363.         int rx_bytes;

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

  365.         {

  366.             net_error_t error = fSocket.GetError();

  367.             //no data isn't really a network error, so just return 0 avalaible read bytes

  368.             if ( error == NET_NO_DATA )

  369.                 return 0;

  370.             else if ( fRunning && ( error == NET_CONN_ERROR ) )

  371.             {

  372.                 //fatal connection issue, exit

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

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

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

  376.                 Exit();

  377.             }

  378.             else if ( fRunning )

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

  380.         }

  381.         return rx_bytes;

  382.     }

  383. 

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

  385.     {

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

  387.         return master->Process();

  388.     }

  389. 

  390.     int JackNetMaster::Process()

  391.     {

  392.         if ( !fRunning )

  393.             return 0;

  394. 

  395.         int tx_bytes = 0;

  396.         int rx_bytes = 0;

  397.         uint midi_recvd_pckt = 0;

  398.         uint jumpcnt = 0;

  399.         fTxHeader.fCycle++;

  400.         fTxHeader.fSubCycle = 0;

  401.         fTxHeader.fIsLastPckt = 'n';

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

  403. 

  404. #ifdef JACK_MONITOR

  405.         jack_time_t begin_time = jack_get_time();

  406.         fMeasureId = 0;

  407. #endif

  408. 

  409.         //buffers

  410.         uint port_index;

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

  412.             fNetMidiCaptureBuffer->SetBuffer ( port_index,

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

  414.                                                                               fParams.fPeriodSize ) ) );

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

  416.             fNetAudioCaptureBuffer->SetBuffer ( port_index,

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

  418.                                                                          fParams.fPeriodSize ) ) );

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

  420.             fNetMidiPlaybackBuffer->SetBuffer ( port_index,

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

  422.                                                                                fParams.fPeriodSize ) ) );

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

  424.             fNetAudioPlaybackBuffer->SetBuffer ( port_index,

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

  426.                                                                           fParams.fPeriodSize ) ) );

  427. 

  428.         //send ------------------------------------------------------------------------------------------------------------------

  429.         //sync : first set header

  430.         fTxHeader.fDataType = 's';

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

  432.             fTxHeader.fIsLastPckt = 'y';

  433.         fTxHeader.fPacketSize = fParams.fMtu;

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

  435.         //sync : then fill auxiliary data

  436.         memset ( fTxData, 0, fPayloadSize );

  437.         SetSyncPacket();

  438.         //sync : and send

  439.         tx_bytes = Send ( fTxBuffer, fTxHeader.fPacketSize, 0 );

  440.         if ( tx_bytes == SOCKET_ERROR )

  441.             return tx_bytes;

  442. 

  443. #ifdef JACK_MONITOR

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

  445. #endif

  446. 

  447.         //midi

  448.         if ( fParams.fSendMidiChannels )

  449.         {

  450.             //set global header fields and get the number of midi packets

  451.             fTxHeader.fDataType = 'm';

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

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

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

  455.             {

  456.                 //fill the packet header fields

  457.                 fTxHeader.fSubCycle = subproc;

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

  459.                     fTxHeader.fIsLastPckt = 'y';

  460.                 //get the data from buffer

  461.                 fTxHeader.fPacketSize = fNetMidiCaptureBuffer->RenderToNetwork ( subproc, fTxHeader.fMidiDataSize );

  462.                 fTxHeader.fPacketSize += sizeof ( packet_header_t );

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

  464.                 //and send

  465.                 tx_bytes = Send ( fTxBuffer, fTxHeader.fPacketSize, 0 );

  466.                 if ( tx_bytes == SOCKET_ERROR )

  467.                     return tx_bytes;

  468.             }

  469.         }

  470. 

  471.         //audio

  472.         if ( fParams.fSendAudioChannels )

  473.         {

  474.             fTxHeader.fDataType = 'a';

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

  476.             {

  477.                 //set the header

  478.                 fTxHeader.fSubCycle = subproc;

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

  480.                     fTxHeader.fIsLastPckt = 'y';

  481.                 fTxHeader.fPacketSize = fAudioTxLen;

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

  483.                 //get the data

  484.                 fNetAudioCaptureBuffer->RenderFromJackPorts ( subproc );

  485.                 //and send

  486.                 tx_bytes = Send ( fTxBuffer, fTxHeader.fPacketSize, 0 );

  487.                 if ( tx_bytes == SOCKET_ERROR )

  488.                     return tx_bytes;

  489.             }

  490.         }

  491. 

  492. #ifdef JACK_MONITOR

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

  494. #endif

  495. 

  496.         //receive --------------------------------------------------------------------------------------------------------------------

  497.         //sync

  498.         rx_bytes = Recv ( fParams.fMtu, MSG_PEEK );

  499.         //wait here for sync, switch network mode :

  500.         //  -fast : this recv will wait for a long time (90% of cycle duration)

  501.         //  -slow : just wait for a short time, then return, the data will be available at the next cycle

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

  503.             return rx_bytes;

  504. 

  505.         //slow mode :

  506.         if ( fParams.fNetworkMasterMode == 's' ) 

  507.         {

  508.             if ( rx_head->fCycle == fTxHeader.fCycle )

  509.                 return 0;

  510.             else 

  511.                 rx_bytes = Recv ( rx_head->fPacketSize, 0);

  512.         }

  513. 

  514.         //fast mode :

  515.         if ( fParams.fNetworkMasterMode == 'f' )

  516.         {

  517.             if ( fTxHeader.fCycle - fRxHeader.fCycle )

  518.                 jack_log ( "%s : %s =  %d", fParams.fName, ( fParams.fSlaveSyncMode ) ? "SyncCycleOffset" : "AsyncCycleOffset", fTxHeader.fCycle - fRxHeader.fCycle );

  519.         }

  520. 

  521. #ifdef JACK_MONITOR

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

  523. #endif

  524. 

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

  526.         {

  527.             do

  528.             {

  529.                 rx_bytes = Recv ( fParams.fMtu, MSG_PEEK );

  530.                 if ( rx_bytes == SOCKET_ERROR )

  531.                     return rx_bytes;

  532.                 if ( ++jumpcnt == fNSubProcess )

  533.                 {

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

  535.                     jumpcnt = 0;

  536.                 }

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

  538.                 {

  539.                     switch ( rx_head->fDataType )

  540.                     {

  541.                         case 'm':   //midi

  542.                             Recv ( rx_head->fPacketSize, 0 );

  543.                             fRxHeader.fCycle = rx_head->fCycle;

  544.                             fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

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

  547.                                 fNetMidiPlaybackBuffer->RenderToJackPorts();

  548.                             jumpcnt = 0;

  549.                             break;

  550.                         case 'a':   //audio

  551.                             Recv ( rx_head->fPacketSize, 0 );

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

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

  554.                             fRxHeader.fCycle = rx_head->fCycle;

  555.                             fRxHeader.fSubCycle = rx_head->fSubCycle;

  556.                             fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

  558.                             jumpcnt = 0;

  559.                             break;

  560.                         case 's':   //sync

  561.                             Recv ( rx_head->fPacketSize, 0 );

  562.                             return 0;

  563.                     }

  564.                 }

  565.             }

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

  567.         }

  568. 

  569. #ifdef JACK_MONITOR

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

  571.         fMonitor->Write ( fMeasure );

  572. #endif

  573.         return 0;

  574.     }

  575. 

  576. //JackNetMasterManager***********************************************************************************************

  577. 

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

  579.     {

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

  581.         fManagerClient = client;

  582.         fManagerName = jack_get_client_name ( fManagerClient );

  583.         fMulticastIP = DEFAULT_MULTICAST_IP;

  584.         fSocket.SetPort ( DEFAULT_PORT );

  585.         fGlobalID = 0;

  586.         fRunning = true;

  587. 

  588.         const JSList* node;

  589.         const jack_driver_param_t* param;

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

  591.         {

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

  593.             switch ( param->character )

  594.             {

  595.                 case 'a' :

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

  597.                     break;

  598.                 case 'p':

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

  600.             }

  601.         }

  602. 

  603.         //set sync callback

  604.         jack_set_sync_callback ( fManagerClient, SetSyncCallback, this );

  605. 

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

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

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

  609. 

  610.         //launch the manager thread

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

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

  613.     }

  614. 

  615.     JackNetMasterManager::~JackNetMasterManager()

  616.     {

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

  618.         Exit();

  619.         master_list_t::iterator it;

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

  621.             delete ( *it );

  622.         fSocket.Close();

  623.         SocketAPIEnd();

  624.     }

  625. 

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

  627.     {

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

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

  630.     }

  631. 

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

  633.     {

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

  635.         int ret = 1;

  636.         master_list_it_t it;

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

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

  639.                 ret = 0;

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

  641.         return ret;

  642.     }

  643. 

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

  645.     {

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

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

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

  649.         master_manager->Run();

  650.         return NULL;

  651.     }

  652. 

  653.     void JackNetMasterManager::Run()

  654.     {

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

  656.         //utility variables

  657.         int usec_timeout = 2000000;

  658.         int attempt = 0;

  659. 

  660.         //data

  661.         session_params_t params;

  662.         int rx_bytes = 0;

  663.         JackNetMaster* net_master;

  664. 

  665.         //init socket API (win32)

  666.         if ( SocketAPIInit() < 0 )

  667.         {

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

  669.             return;

  670.         }

  671. 

  672.         //socket

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

  674.         {

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

  676.             return;

  677.         }

  678. 

  679.         //bind the socket to the local port

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

  681.         {

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

  683.             fSocket.Close();

  684.             return;

  685.         }

  686. 

  687.         //join multicast group

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

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

  690. 

  691.         //local loop

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

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

  694. 

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

  696.         if ( fSocket.SetTimeOut ( usec_timeout ) == SOCKET_ERROR )

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

  698. 

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

  700. 

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

  702.         do

  703.         {

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

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

  706.             {

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

  708.                 if ( ++attempt == 10 )

  709.                 {

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

  711.                     return;

  712.                 }

  713.             }

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

  715.             {

  716.                 switch ( GetPacketType ( &params ) )

  717.                 {

  718.                     case SLAVE_AVAILABLE:

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

  720.                             SessionParamsDisplay ( &net_master->fParams );

  721.                         else

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

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

  724.                         break;

  725.                     case KILL_MASTER:

  726.                         if ( KillMaster ( &params ) )

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

  728.                         break;

  729.                     default:

  730.                         break;

  731.                 }

  732.             }

  733.         }

  734.         while ( fRunning );

  735.     }

  736. 

  737.     void JackNetMasterManager::Exit()

  738.     {

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

  740.         fRunning = false;

  741.         jack_client_stop_thread ( fManagerClient, fManagerThread );

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

  743.     }

  744. 

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

  746.     {

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

  748.         //settings

  749.         fSocket.GetName ( params.fMasterNetName );

  750.         params.fID = ++fGlobalID;

  751.         params.fSampleRate = jack_get_sample_rate ( fManagerClient );

  752.         params.fPeriodSize = jack_get_buffer_size ( fManagerClient );

  753.         params.fBitdepth = 0;

  754.         SetFramesPerPacket ( &params );

  755.         SetSlaveName ( params );

  756. 

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

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

  759.         if ( master->Init() )

  760.         {

  761.             fMasterList.push_back ( master );

  762.             return master;

  763.         }

  764.         delete master;

  765.         return NULL;

  766.     }

  767. 

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

  769.     {

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

  771.         master_list_it_t it;

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

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

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

  775.     }

  776. 

  777.     master_list_it_t JackNetMasterManager::FindMaster ( uint32_t id )

  778.     {

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

  780.         master_list_it_t it;

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

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

  783.                 return it;

  784.         return it;

  785.     }

  786. 

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

  788.     {

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

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

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

  792.         {

  793.             fMasterList.erase ( master );

  794.             delete *master;

  795.             return 1;

  796.         }

  797.         return 0;

  798.     }

  799. }//namespace

  800. 

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

  802. 

  803. #ifdef __cplusplus

  804. extern "C"

  805. {

  806. #endif

  807. 

  808.     EXPORT jack_driver_desc_t* jack_get_descriptor()

  809.     {

  810.         jack_driver_desc_t *desc;

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

  812. 

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

  814.         desc->nparams = 2;

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

  816. 

  817.         int i = 0;

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

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

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

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

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

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

  824. 

  825.         i++;

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

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

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

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

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

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

  832. 

  833.         return desc;

  834.     }

  835. 

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

  837.     {

  838.         if ( master_manager )

  839.         {

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

  841.             return 1;

  842.         }

  843.         else

  844.         {

  845.             jack_log ( "Loading Master Manager" );

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

  847.             return ( master_manager ) ? 0 : 1;

  848.         }

  849.     }

  850. 

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

  852.     {

  853.         JSList* params = NULL;

  854.         jack_driver_desc_t* desc = jack_get_descriptor();

  855.         Jack::JackArgParser parser ( load_init );

  856. 

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

  858.         {

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

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

  861.         }

  862. 

  863.         return jack_internal_initialize ( jack_client, params );

  864.     }

  865. 

  866.     EXPORT void jack_finish ( void* arg )

  867.     {

  868.         if ( master_manager )

  869.         {

  870.             jack_log ( "Unloading Master Manager" );

  871.             delete master_manager;

  872.             master_manager = NULL;

  873.         }

  874.     }

  875. #ifdef __cplusplus

  876. }

  877. #endif