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

742 lines
28KB
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. #include "JackError.h"

  22. #include "JackExports.h"

  23. #include "driver_interface.h"

  24. 

  25. #define DEFAULT_MULTICAST_IP "225.3.19.154"

  26. #define DEFAULT_PORT 19000

  27. 

  28. using namespace std;

  29. 

  30. namespace Jack

  31. {

  32. //JackNetMaster******************************************************************************************************

  33. 

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

  35.     {

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

  37.         //settings

  38.         fMasterManager = manager;

  39.         fParams = params;

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

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

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

  43.         fNetJumpCnt = 0;

  44.         fJackClient = NULL;

  45.         fRunning = false;

  46.         uint port_index;

  47. 

  48.         //jack audio ports

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

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

  51.             fAudioCapturePorts[port_index] = NULL;

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

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

  54.             fAudioPlaybackPorts[port_index] = NULL;

  55.         //jack midi ports

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

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

  58.             fMidiCapturePorts[port_index] = NULL;

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

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

  61.             fMidiPlaybackPorts[port_index] = NULL;

  62. 

  63.         //TX header init

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

  65.         fTxHeader.fDataStream = 's';

  66.         fTxHeader.fID = fParams.fID;

  67.         fTxHeader.fCycle = 0;

  68.         fTxHeader.fSubCycle = 0;

  69.         fTxHeader.fMidiDataSize = 0;

  70.         fTxHeader.fBitdepth = fParams.fBitdepth;

  71. 

  72.         //RX header init

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

  74.         fRxHeader.fDataStream = 'r';

  75.         fRxHeader.fID = fParams.fID;

  76.         fRxHeader.fCycle = 0;

  77.         fRxHeader.fSubCycle = 0;

  78.         fRxHeader.fMidiDataSize = 0;

  79.         fRxHeader.fBitdepth = fParams.fBitdepth;

  80. 

  81.         //network buffers

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

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

  84. 

  85.         //net audio buffers

  86.         fTxData = fTxBuffer + sizeof ( packet_header_t );

  87.         fRxData = fRxBuffer + sizeof ( packet_header_t );

  88. 

  89.         //midi net buffers

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

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

  92. 

  93.         //audio net buffers

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

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

  96. 

  97.         //audio netbuffer length

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

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

  100.     }

  101. 

  102.     JackNetMaster::~JackNetMaster()

  103.     {

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

  105.         if ( fJackClient )

  106.         {

  107.             jack_deactivate ( fJackClient );

  108.             FreePorts();

  109.             jack_client_close ( fJackClient );

  110.         }

  111.         fSocket.Close();

  112.         delete fNetAudioCaptureBuffer;

  113.         delete fNetAudioPlaybackBuffer;

  114.         delete fNetMidiCaptureBuffer;

  115.         delete fNetMidiPlaybackBuffer;

  116.         delete[] fAudioCapturePorts;

  117.         delete[] fAudioPlaybackPorts;

  118.         delete[] fMidiCapturePorts;

  119.         delete[] fMidiPlaybackPorts;

  120.         delete[] fTxBuffer;

  121.         delete[] fRxBuffer;

  122.     }

  123. 

  124.     bool JackNetMaster::Init()

  125.     {

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

  127.         session_params_t params;

  128.         int msec_timeout = 1000;

  129.         uint attempt = 0;

  130.         int rx_bytes = 0;

  131. 

  132.         //socket

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

  134.         {

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

  136.             return false;

  137.         }

  138. 

  139.         //timeout on receive (for init)

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

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

  142. 

  143.         //connect

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

  145.         {

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

  147.             return false;

  148.         }

  149. 

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

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

  152.         do

  153.         {

  154.             SetPacketType ( &fParams, SLAVE_SETUP );

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

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

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

  158.             {

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

  160.                 return false;

  161.             }

  162.         }

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

  164.         if ( attempt == 5 )

  165.         {

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

  167.             return false;

  168.         }

  169. 

  170.         //set the new timeout for the socket

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

  172.         {

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

  174.             return false;

  175.         }

  176. 

  177.         //jack client and process

  178.         jack_status_t status;

  179.         jack_options_t options = JackNullOption;

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

  181.         {

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

  183.             return false;

  184.         }

  185. 

  186.         jack_set_process_callback ( fJackClient, SetProcess, this );

  187. 

  188.         //port registering

  189.         uint i;

  190.         char name[24];

  191.         jack_nframes_t port_latency = jack_get_buffer_size ( fJackClient );

  192.         unsigned long port_flags;

  193.         //audio

  194.         port_flags = JackPortIsInput | JackPortIsTerminal;

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

  196.         {

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

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

  199.                 goto fail;

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

  201.         }

  202.         port_flags = JackPortIsOutput | JackPortIsTerminal;

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

  204.         {

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

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

  207.                 goto fail;

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

  209.         }

  210.         //midi

  211.         port_flags = JackPortIsInput | JackPortIsTerminal;

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

  213.         {

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

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

  216.                 goto fail;

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

  218.         }

  219.         port_flags = JackPortIsOutput | JackPortIsTerminal;

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

  221.         {

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

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

  224.                 goto fail;

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

  226.         }

  227. 

  228.         fRunning = true;

  229. 

  230.         //finally activate jack client

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

  232.         {

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

  234.             goto fail;

  235.         }

  236. 

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

  238. 

  239.         return true;

  240. 

  241. fail:

  242.         FreePorts();

  243.         jack_client_close ( fJackClient );

  244.         fJackClient = NULL;

  245.         return false;

  246.     }

  247. 

  248.     void JackNetMaster::FreePorts()

  249.     {

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

  251.         uint port_index;

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

  253.             if ( fAudioCapturePorts[port_index] )

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

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

  256.             if ( fAudioPlaybackPorts[port_index] )

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

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

  259.             if ( fMidiCapturePorts[port_index] )

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

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

  262.             if ( fMidiPlaybackPorts[port_index] )

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

  264.     }

  265. 

  266.     void JackNetMaster::Exit()

  267.     {

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

  269.         //stop process

  270.         fRunning = false;

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

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

  273.         SetPacketType ( &fParams, KILL_MASTER );

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

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

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

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

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

  279.         mcast_socket.Close();

  280.     }

  281. 

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

  283.     {

  284.         int tx_bytes;

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

  286.         {

  287.             net_error_t error = fSocket.GetError();

  288.             if ( error == NET_CONN_ERROR )

  289.             {

  290.                 //fatal connection issue, exit

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

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

  293.                 Exit();

  294.                 return 0;

  295.             }

  296.             else

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

  298.         }

  299.         return tx_bytes;

  300.     }

  301. 

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

  303.     {

  304.         int rx_bytes;

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

  306.         {

  307.             net_error_t error = fSocket.GetError();

  308.             if ( error == NET_NO_DATA )

  309.             {

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

  311.                 if ( ++fNetJumpCnt == 100 )

  312.                 {

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

  314.                     fNetJumpCnt = 0;

  315.                 }

  316.                 return 0;

  317.             }

  318.             else if ( error == NET_CONN_ERROR )

  319.             {

  320.                 //fatal connection issue, exit

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

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

  323.                 Exit();

  324.                 return 0;

  325.             }

  326.             else

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

  328.         }

  329.         return rx_bytes;

  330.     }

  331. 

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

  333.     {

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

  335.         return master->Process();

  336.     }

  337. 

  338.     int JackNetMaster::Process()

  339.     {

  340.         if ( !fRunning )

  341.             return 0;

  342. 

  343.         int tx_bytes, rx_bytes, copy_size;

  344.         size_t midi_recvd_pckt = 0;

  345.         fTxHeader.fCycle++;

  346.         fTxHeader.fSubCycle = 0;

  347.         fTxHeader.fIsLastPckt = 'n';

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

  349. 

  350.         //buffers

  351.         uint port_index;

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

  353.             fNetMidiCaptureBuffer->SetBuffer(port_index,

  354.                 static_cast<JackMidiBuffer*> ( jack_port_get_buffer ( fMidiCapturePorts[port_index], fParams.fPeriodSize )));

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

  356.             fNetAudioCaptureBuffer->SetBuffer(port_index,

  357.                 static_cast<sample_t*> ( jack_port_get_buffer ( fAudioCapturePorts[port_index], fParams.fPeriodSize )));

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

  359.             fNetMidiPlaybackBuffer->SetBuffer(port_index,

  360.                 static_cast<JackMidiBuffer*> ( jack_port_get_buffer ( fMidiPlaybackPorts[port_index], fParams.fPeriodSize )));

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

  362.             fNetAudioPlaybackBuffer->SetBuffer(port_index,

  363.                 static_cast<sample_t*> ( jack_port_get_buffer ( fAudioPlaybackPorts[port_index], fParams.fPeriodSize )));

  364. 

  365.         //send ------------------------------------------------------------------------------------------------------------------

  366.         //sync

  367.         fTxHeader.fDataType = 's';

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

  369.             fTxHeader.fIsLastPckt = 'y';

  370.         tx_bytes = Send ( reinterpret_cast<char*> ( &fTxHeader ), sizeof ( packet_header_t ), 0 );

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

  372.             return tx_bytes;

  373. 

  374.         //midi

  375.         if ( fParams.fSendMidiChannels )

  376.         {

  377.             fTxHeader.fDataType = 'm';

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

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

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

  381.             {

  382.                 fTxHeader.fSubCycle = subproc;

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

  384.                     fTxHeader.fIsLastPckt = 'y';

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

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

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

  388.                 if ( tx_bytes < 1 )

  389.                     return tx_bytes;

  390.             }

  391.         }

  392. 

  393.         //audio

  394.         if ( fParams.fSendAudioChannels )

  395.         {

  396.             fTxHeader.fDataType = 'a';

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

  398.             {

  399.                 fTxHeader.fSubCycle = subproc;

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

  401.                     fTxHeader.fIsLastPckt = 'y';

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

  403.                 fNetAudioCaptureBuffer->RenderFromJackPorts ( subproc );

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

  405.                 if ( tx_bytes < 1 )

  406.                     return tx_bytes;

  407.             }

  408.         }

  409. 

  410.         //receive ( if there is stg to receive...)-------------------------------------------------------------------------------------

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

  412.         {

  413.             do

  414.             {

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

  416.                 if ( rx_bytes < 1 )

  417.                     return rx_bytes;

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

  419.                 {

  420.                     switch ( rx_head->fDataType )

  421.                     {

  422.                     case 'm':	//midi

  423.                         rx_bytes = Recv ( rx_bytes, 0 );

  424.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

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

  427.                             fNetMidiPlaybackBuffer->RenderToJackPorts();

  428.                         fNetJumpCnt = 0;

  429.                         break;

  430.                     case 'a':	//audio

  431.                         rx_bytes = Recv ( fAudioRxLen, 0 );

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

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

  434.                         fRxHeader.fCycle = rx_head->fCycle;

  435.                         fRxHeader.fSubCycle = rx_head->fSubCycle;

  436.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

  438.                         fNetJumpCnt = 0;

  439.                         break;

  440.                     }

  441.                 }

  442.             }

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

  444.         }

  445.         return 0;

  446.     }

  447. 

  448. //JackNetMasterManager***********************************************************************************************

  449. 

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

  451.     {

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

  453.         fManagerClient = client;

  454.         fManagerName = jack_get_client_name ( fManagerClient );

  455.         fMulticastIP = DEFAULT_MULTICAST_IP;

  456.         fSocket.SetPort ( DEFAULT_PORT );

  457.         fGlobalID = 0;

  458.         fRunning = true;

  459. 

  460.         const JSList* node;

  461.         const jack_driver_param_t* param;

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

  463.         {

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

  465.             switch ( param->character )

  466.             {

  467.             case 'a' :

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

  469.                 break;

  470.             case 'p':

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

  472.             }

  473.         }

  474. 

  475. 		jack_set_sync_callback ( fManagerClient, SetSyncCallback, this );

  476. 

  477.         //activate the client

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

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

  480. 

  481.         //launch the manager thread

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

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

  484.     }

  485. 

  486.     JackNetMasterManager::~JackNetMasterManager()

  487.     {

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

  489.         Exit();

  490.         master_list_t::iterator it;

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

  492.             delete ( *it );

  493.         fSocket.Close();

  494.         SocketAPIEnd();

  495.     }

  496. 

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

  498.     {

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

  500.     	master_manager->SyncCallback ( state, pos );

  501. 		return 1;

  502.     }

  503. 

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

  505.     {

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

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

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

  509.         master_manager->Run();

  510.         return NULL;

  511.     }

  512. 

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

  514. 	{

  515. 		jack_log ( "JackNetMasterManager::SyncCallback" );

  516. 		return 0;

  517. 	}

  518. 

  519.     void JackNetMasterManager::Run()

  520.     {

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

  522.         //utility variables

  523.         int msec_timeout = 2000;

  524.         int attempt = 0;

  525. 

  526.         //data

  527.         session_params_t params;

  528.         int rx_bytes = 0;

  529.         JackNetMaster* net_master;

  530. 

  531.         //init socket API (win32)

  532.         if ( SocketAPIInit() < 0 )

  533.         {

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

  535.             return;

  536.         }

  537. 

  538.         //socket

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

  540.         {

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

  542.             return;

  543.         }

  544. 

  545.         //bind the socket to the local port

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

  547.         {

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

  549.             fSocket.Close();

  550.             return;

  551.         }

  552. 

  553.         //join multicast group

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

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

  556. 

  557.         //local loop

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

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

  560. 

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

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

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

  564. 

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

  566. 

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

  568.         do

  569.         {

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

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

  572.             {

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

  574.                 if ( ++attempt == 10 )

  575.                 {

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

  577.                     return;

  578.                 }

  579.             }

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

  581.             {

  582.                 switch ( GetPacketType ( &params ) )

  583.                 {

  584.                 case SLAVE_AVAILABLE:

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

  586.                         SessionParamsDisplay ( &net_master->fParams );

  587.                     else

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

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

  590.                     break;

  591.                 case KILL_MASTER:

  592.                     KillMaster ( &params );

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

  594.                     break;

  595.                 default:

  596.                     break;

  597.                 }

  598.             }

  599.         }

  600.         while ( fRunning );

  601.     }

  602. 

  603.     void JackNetMasterManager::Exit()

  604.     {

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

  606.         fRunning = false;

  607.         jack_client_stop_thread ( fManagerClient, fManagerThread );

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

  609.     }

  610. 

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

  612.     {

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

  614.         //settings

  615.         fSocket.GetName ( params.fMasterNetName );

  616.         params.fID = ++fGlobalID;

  617.         params.fSampleRate = jack_get_sample_rate ( fManagerClient );

  618.         params.fPeriodSize = jack_get_buffer_size ( fManagerClient );

  619.         params.fBitdepth = 0;

  620.         SetFramesPerPacket ( &params );

  621.         SetSlaveName ( params );

  622. 

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

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

  625.         if ( master->Init() )

  626.         {

  627.             fMasterList.push_back ( master );

  628.             return master;

  629.         }

  630.         delete master;

  631.         return NULL;

  632.     }

  633. 

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

  635.     {

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

  637.         master_list_it_t it;

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

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

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

  641.     }

  642. 

  643.     master_list_it_t JackNetMasterManager::FindMaster ( uint32_t id )

  644.     {

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

  646.         master_list_it_t it;

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

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

  649.                 return it;

  650.         return it;

  651.     }

  652. 

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

  654.     {

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

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

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

  658.         {

  659.             fMasterList.erase ( master );

  660.             delete *master;

  661.         }

  662.     }

  663. }//namespace

  664. 

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

  666. 

  667. #ifdef __cplusplus

  668. extern "C"

  669. {

  670. #endif

  671. 

  672.     EXPORT jack_driver_desc_t* jack_get_descriptor()

  673.     {

  674.         jack_driver_desc_t *desc;

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

  676. 

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

  678.         desc->nparams = 2;

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

  680. 

  681.         int i = 0;

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

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

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

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

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

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

  688. 

  689.         i++;

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

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

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

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

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

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

  696. 

  697.         return desc;

  698.     }

  699. 

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

  701.     {

  702.         if ( master_manager )

  703.         {

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

  705.             return 1;

  706.         }

  707.         else

  708.         {

  709.             jack_log ( "Loading Master Manager" );

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

  711.             return ( master_manager ) ? 0 : 1;

  712.         }

  713.     }

  714. 

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

  716.     {

  717.         JSList* params = NULL;

  718.         jack_driver_desc_t* desc = jack_get_descriptor();

  719.         Jack::JackArgParser parser ( load_init );

  720. 

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

  722.         {

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

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

  725.         }

  726. 

  727.         return jack_internal_initialize(jack_client, params);

  728.     }

  729. 

  730.     EXPORT void jack_finish ( void* arg )

  731.     {

  732.         if ( master_manager )

  733.         {

  734.             jack_log ( "Unloading Master Manager" );

  735.             delete master_manager;

  736.             master_manager = NULL;

  737.         }

  738.     }

  739. #ifdef __cplusplus

  740. }

  741. #endif