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.
1173 Commits
7 Branches
62MB
Tree: 9221bc14d0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9221bc14d0'
${ noResults }
jack2/common/JackNetDriver.cpp

882 lines
36KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2001 Paul Davis

  3. Copyright (C) 2008 Romain Moret at Grame

  4. 

  5. This program is free software; you can redistribute it and/or modify

  6. it under the terms of the GNU General Public License as published by

  7. the Free Software Foundation; either version 2 of the License, or

  8. (at your option) any later version.

  9. 

  10. This program is distributed in the hope that it will be useful,

  11. but WITHOUT ANY WARRANTY; without even the implied warranty of

  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13. GNU General Public License for more details.

  14. 

  15. You should have received a copy of the GNU General Public License

  16. along with this program; if not, write to the Free Software

  17. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  18. 

  19. */

  20. 

  21. #include "JackNetDriver.h"

  22. #include "JackEngineControl.h"

  23. #include "JackClientControl.h"

  24. #include "JackGraphManager.h"

  25. #include "JackDriverLoader.h"

  26. #include "JackThreadedDriver.h"

  27. #include "JackWaitThreadedDriver.h"

  28. #include "JackException.h"

  29. 

  30. #define DEFAULT_MULTICAST_IP "225.3.19.154"

  31. #define DEFAULT_PORT 19000

  32. 

  33. using namespace std;

  34. 

  35. namespace Jack

  36. {

  37.     JackNetDriver::JackNetDriver ( const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table,

  38.                                    const char* ip, int port, int mtu, int midi_input_ports, int midi_output_ports,

  39.                                    const char* net_name, uint transport_sync, char network_mode )

  40.             : JackAudioDriver ( name, alias, engine, table ), fSocket ( ip, port )

  41.     {

  42.         jack_log ( "JackNetDriver::JackNetDriver ip %s, port %d", ip, port );

  43. 

  44.         fMulticastIP = new char[strlen ( ip ) + 1];

  45.         strcpy ( fMulticastIP, ip );

  46.         fParams.fMtu = mtu;

  47.         fParams.fSendMidiChannels = midi_input_ports;

  48.         fParams.fReturnMidiChannels = midi_output_ports;

  49.         strcpy ( fParams.fName, net_name );

  50.         fSocket.GetName ( fParams.fSlaveNetName );

  51.         fParams.fTransportSync = transport_sync;

  52.         fParams.fNetworkMode = network_mode;

  53. #ifdef JACK_MONITOR

  54.         fNetTimeMon = NULL;

  55.         fCycleTimeMon = NULL;

  56. #endif

  57.     }

  58. 

  59.     JackNetDriver::~JackNetDriver()

  60.     {

  61.         fSocket.Close();

  62.         SocketAPIEnd();

  63.         delete fNetAudioCaptureBuffer;

  64.         delete fNetAudioPlaybackBuffer;

  65.         delete fNetMidiCaptureBuffer;

  66.         delete fNetMidiPlaybackBuffer;

  67.         delete[] fTxBuffer;

  68.         delete[] fRxBuffer;

  69.         delete[] fMulticastIP;

  70.         delete[] fMidiCapturePortList;

  71.         delete[] fMidiPlaybackPortList;

  72. #ifdef JACK_MONITOR

  73.         delete fNetTimeMon;

  74.         delete fCycleTimeMon;

  75. #endif

  76.     }

  77. 

  78. //*************************************initialization***********************************************************************

  79. 

  80.     int JackNetDriver::Open ( jack_nframes_t buffer_size, jack_nframes_t samplerate, bool capturing, bool playing,

  81.                               int inchannels, int outchannels, bool monitor,

  82.                               const char* capture_driver_name, const char* playback_driver_name,

  83.                               jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  84.     {

  85.         int res = JackAudioDriver::Open ( buffer_size, samplerate, capturing, playing, inchannels, outchannels, monitor,

  86.                                           capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  87.         fEngineControl->fPeriod = 0;

  88.         fEngineControl->fComputation = 500 * 1000;

  89.         fEngineControl->fConstraint = 500 * 1000;

  90.         return res;

  91.     }

  92. 

  93. #ifdef JACK_MONITOR

  94.     int JackNetDriver::Close()

  95.     {

  96.         if ( fNetTimeMon )

  97.             fNetTimeMon->Save();

  98.         if ( fCycleTimeMon )

  99.             fCycleTimeMon->Save();

  100.         return JackDriver::Close();

  101.     }

  102. #endif

  103. 

  104.     int JackNetDriver::Attach()

  105.     {

  106.         return 0;

  107.     }

  108. 

  109.     int JackNetDriver::Detach()

  110.     {

  111.         return 0;

  112.     }

  113. 

  114.     bool JackNetDriver::Init()

  115.     {

  116.         jack_log ( "JackNetDriver::Init()" );

  117. 

  118.         //new loading, but existing socket, restart the driver

  119.         if ( fSocket.IsSocket() )

  120.             Restart();

  121. 

  122.         //set the parameters to send

  123.         strcpy ( fParams.fPacketType, "params" );

  124.         fParams.fProtocolVersion = 'a';

  125.         SetPacketType ( &fParams, SLAVE_AVAILABLE );

  126.         fParams.fSendAudioChannels = fCaptureChannels;

  127.         fParams.fReturnAudioChannels = fPlaybackChannels;

  128.         fParams.fSlaveSyncMode = fEngineControl->fSyncMode;

  129. 

  130.         //is transport sync ?

  131.         if ( fParams.fTransportSync )

  132.             jack_info ( "NetDriver started with Master's Transport Sync." );

  133. 

  134.         //init loop : get a master and start, do it until connection is ok

  135.         net_status_t status;

  136.         do

  137.         {

  138.             //first, get a master, do it until a valid connection is running

  139.             jack_info ( "Initializing Net Driver..." );

  140.             do

  141.             {

  142.                 status = GetNetMaster();

  143.                 if ( status == NET_SOCKET_ERROR )

  144.                     return false;

  145.             }

  146.             while ( status != NET_CONNECTED );

  147. 

  148.             //then tell the master we are ready

  149.             jack_info ( "Initializing connection with %s...", fParams.fMasterNetName );

  150.             status = SendMasterStartSync();

  151.             if ( status == NET_ERROR )

  152.                 return false;

  153.         }

  154.         while ( status != NET_ROLLING );

  155. 

  156.         //driver parametering

  157.         if ( SetParams() )

  158.         {

  159.             jack_error ( "Fatal error : can't alloc net driver ports." );

  160.             return false;

  161.         }

  162. 

  163.         //init done, display parameters

  164.         SessionParamsDisplay ( &fParams );

  165. 

  166.         return true;

  167.     }

  168. 

  169.     net_status_t JackNetDriver::GetNetMaster()

  170.     {

  171.         jack_log ( "JackNetDriver::GetNetMaster()" );

  172.         //utility

  173.         session_params_t params;

  174.         int us_timeout = 2000000;

  175.         int rx_bytes = 0;

  176.         unsigned char loop = 0;

  177. 

  178.         //socket

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

  180.         {

  181.             jack_error ( "Fatal error : network unreachable - %s", StrError ( NET_ERROR_CODE ) );

  182.             return NET_SOCKET_ERROR;

  183.         }

  184. 

  185.         //bind the socket

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

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

  188. 

  189.         //timeout on receive

  190.         if ( fSocket.SetTimeOut ( us_timeout ) == SOCKET_ERROR )

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

  192. 

  193.         //disable local loop

  194.         if ( fSocket.SetOption ( IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof ( loop ) ) == SOCKET_ERROR )

  195.             jack_error ( "Can't disable multicast loop : %s", StrError ( NET_ERROR_CODE ) );

  196. 

  197.         //send 'AVAILABLE' until 'SLAVE_SETUP' received

  198.         jack_info ( "Waiting for a master..." );

  199.         do

  200.         {

  201.             //send 'available'

  202.             if ( fSocket.SendTo ( &fParams, sizeof ( session_params_t ), 0, fMulticastIP ) == SOCKET_ERROR )

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

  204.             //filter incoming packets : don't exit while no error is detected

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

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

  207.             {

  208.                 jack_error ( "Can't receive : %s", StrError ( NET_ERROR_CODE ) );

  209.                 return NET_RECV_ERROR;

  210.             }

  211.         }

  212.         while ( strcmp ( params.fPacketType, fParams.fPacketType ) && ( GetPacketType ( &params ) != SLAVE_SETUP ) );

  213. 

  214.         //connect the socket

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

  216.         {

  217.             jack_error ( "Error in connect : %s", StrError ( NET_ERROR_CODE ) );

  218.             return NET_CONNECT_ERROR;

  219.         }

  220. 

  221.         //everything is OK, copy parameters and return

  222.         fParams = params;

  223. 

  224.         return NET_CONNECTED;

  225.     }

  226. 

  227.     net_status_t JackNetDriver::SendMasterStartSync()

  228.     {

  229.         jack_log ( "JackNetDriver::GetNetMasterStartSync()" );

  230.         //tell the master to start

  231.         SetPacketType ( &fParams, START_MASTER );

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

  233.         {

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

  235.             return ( fSocket.GetError() == NET_CONN_ERROR ) ? NET_ERROR : NET_SEND_ERROR;

  236.         }

  237.         return NET_ROLLING;

  238.     }

  239. 

  240.     void JackNetDriver::Restart()

  241.     {

  242.         jack_log ( "JackNetDriver::Restart" );

  243.         jack_info ( "Restarting driver..." );

  244.         delete[] fTxBuffer;

  245.         fTxBuffer = NULL;

  246.         delete[] fRxBuffer;

  247.         fRxBuffer = NULL;

  248.         delete fNetAudioCaptureBuffer;

  249.         fNetAudioCaptureBuffer = NULL;

  250.         delete fNetAudioPlaybackBuffer;

  251.         fNetAudioPlaybackBuffer = NULL;

  252.         delete fNetMidiCaptureBuffer;

  253.         fNetMidiCaptureBuffer = NULL;

  254.         delete fNetMidiPlaybackBuffer;

  255.         fNetMidiPlaybackBuffer = NULL;

  256.         FreePorts();

  257.         delete[] fMidiCapturePortList;

  258.         fMidiCapturePortList = NULL;

  259.         delete[] fMidiPlaybackPortList;

  260.         fMidiPlaybackPortList = NULL;

  261. #ifdef JACK_MONITOR

  262.         delete fNetTimeMon;

  263.         fNetTimeMon = NULL;

  264.         delete fCycleTimeMon;

  265.         fCycleTimeMon = NULL;

  266. #endif

  267.     }

  268. 

  269.     int JackNetDriver::SetParams()

  270.     {

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

  272.         JackAudioDriver::SetBufferSize ( fParams.fPeriodSize );

  273.         JackAudioDriver::SetSampleRate ( fParams.fSampleRate );

  274. 

  275.         JackDriver::NotifyBufferSize ( fParams.fPeriodSize );

  276.         JackDriver::NotifySampleRate ( fParams.fSampleRate );

  277. 

  278.         //allocate midi ports lists

  279.         fMidiCapturePortList = new jack_port_id_t [fParams.fSendMidiChannels];

  280.         fMidiPlaybackPortList = new jack_port_id_t [fParams.fReturnMidiChannels];

  281. 

  282.         //register jack ports

  283.         if ( AllocPorts() != 0 )

  284.         {

  285.             jack_error ( "Can't allocate ports." );

  286.             return -1;

  287.         }

  288. 

  289.         //TX header init

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

  291.         fTxHeader.fDataStream = 'r';

  292.         fTxHeader.fID = fParams.fID;

  293.         fTxHeader.fCycle = 0;

  294.         fTxHeader.fSubCycle = 0;

  295.         fTxHeader.fMidiDataSize = 0;

  296.         fTxHeader.fBitdepth = fParams.fBitdepth;

  297. 

  298.         //RX header init

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

  300.         fRxHeader.fDataStream = 's';

  301.         fRxHeader.fID = fParams.fID;

  302.         fRxHeader.fCycle = 0;

  303.         fRxHeader.fSubCycle = 0;

  304.         fRxHeader.fMidiDataSize = 0;

  305.         fRxHeader.fBitdepth = fParams.fBitdepth;

  306. 

  307.         //network buffers

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

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

  310. 

  311.         //net audio/midi buffers

  312.         fTxData = fTxBuffer + sizeof ( packet_header_t );

  313.         fRxData = fRxBuffer + sizeof ( packet_header_t );

  314. 

  315.         //midi net buffers

  316.         fNetMidiCaptureBuffer = new NetMidiBuffer ( &fParams, fParams.fSendMidiChannels, fRxData );

  317.         fNetMidiPlaybackBuffer = new NetMidiBuffer ( &fParams, fParams.fReturnMidiChannels, fTxData );

  318. 

  319.         //audio net buffers

  320.         fNetAudioCaptureBuffer = new NetAudioBuffer ( &fParams, fParams.fSendAudioChannels, fRxData );

  321.         fNetAudioPlaybackBuffer = new NetAudioBuffer ( &fParams, fParams.fReturnAudioChannels, fTxData );

  322. 

  323.         //audio netbuffer length

  324.         fAudioTxLen = sizeof ( packet_header_t ) + fNetAudioPlaybackBuffer->GetSize();

  325.         fAudioRxLen = sizeof ( packet_header_t ) + fNetAudioCaptureBuffer->GetSize();

  326. 

  327.         //payload size

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

  329. 

  330.         //monitor

  331. #ifdef JACK_MONITOR

  332.         string plot_name;

  333.         //NetTimeMon

  334.         plot_name = string ( fParams.fName );

  335.         plot_name += string ( "_slave" );

  336.         plot_name += ( fEngineControl->fSyncMode ) ? string ( "_sync" ) : string ( "_async" );

  337.         plot_name += ( fParams.fNetworkMode == 'f' ) ? string ( "_fast" ) : string ( "_normal" );

  338.         fNetTimeMon = new JackGnuPlotMonitor<float> ( 128, 4, plot_name );

  339.         string net_time_mon_fields[] =

  340.         {

  341.             string ( "end of read" ),

  342.             string ( "start of write" ),

  343.             string ( "sync send" ),

  344.             string ( "end of write" )

  345.         };

  346.         string net_time_mon_options[] =

  347.         {

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

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

  350.         };

  351.         fNetTimeMon->SetPlotFile ( net_time_mon_options, 2, net_time_mon_fields, 4 );

  352.         //CycleTimeMon

  353.         plot_name.clear();

  354.         plot_name = string ( fParams.fName );

  355.         plot_name += string ( "_slave_cycle_duration" );

  356.         plot_name += ( fEngineControl->fSyncMode ) ? string ( "_sync" ) : string ( "_async" );

  357.         plot_name += ( fParams.fNetworkMode == 'f' ) ? string ( "_fast" ) : string ( "_normal" );

  358.         fCycleTimeMon = new JackGnuPlotMonitor<jack_time_t> ( 2048, 1, plot_name );

  359.         string cycle_time_mon_field = string ( "cycle duration" );

  360.         string cycle_time_mon_options[] =

  361.         {

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

  363.             string ( "set ylabel \"usecs\"" )

  364.         };

  365.         fCycleTimeMon->SetPlotFile ( cycle_time_mon_options, 2, &cycle_time_mon_field, 1 );

  366.         fLastCycleBeginDate = GetMicroSeconds();

  367. #endif

  368. 

  369.         return 0;

  370.     }

  371. 

  372.     int JackNetDriver::AllocPorts()

  373.     {

  374.         jack_log ( "JackNetDriver::AllocPorts fBufferSize = %ld fSampleRate = %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate );

  375.         JackPort* port;

  376.         jack_port_id_t port_id;

  377.         char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  378.         char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  379.         unsigned long port_flags;

  380.         int audio_port_index;

  381.         uint midi_port_index;

  382. 

  383.         //audio

  384.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  385.         for ( audio_port_index = 0; audio_port_index < fCaptureChannels; audio_port_index++ )

  386.         {

  387.             snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:out%d", fAliasName, fCaptureDriverName, audio_port_index + 1 );

  388.             snprintf ( name, sizeof ( name ) - 1, "%s:capture_%d", fClientControl.fName, audio_port_index + 1 );

  389.             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE,

  390.                              static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )

  391.             {

  392.                 jack_error ( "driver: cannot register port for %s", name );

  393.                 return -1;

  394.             }

  395.             port = fGraphManager->GetPort ( port_id );

  396.             port->SetAlias ( alias );

  397.             port->SetLatency ( fEngineControl->fBufferSize );

  398.             fCapturePortList[audio_port_index] = port_id;

  399.             jack_log ( "JackNetDriver::AllocPorts() fCapturePortList[%d] audio_port_index = %ld fPortLatency = %ld", audio_port_index, port_id, port->GetLatency() );

  400.         }

  401.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  402.         for ( audio_port_index = 0; audio_port_index < fPlaybackChannels; audio_port_index++ )

  403.         {

  404.             snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:in%d", fAliasName, fPlaybackDriverName, audio_port_index + 1 );

  405.             snprintf ( name, sizeof ( name ) - 1, "%s:playback_%d",fClientControl.fName, audio_port_index + 1 );

  406.             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE,

  407.                              static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )

  408.             {

  409.                 jack_error ( "driver: cannot register port for %s", name );

  410.                 return -1;

  411.             }

  412.             port = fGraphManager->GetPort ( port_id );

  413.             port->SetAlias ( alias );

  414.             port->SetLatency ( ( fParams.fNetworkMode == 'f' ) ? 0 : fEngineControl->fBufferSize + ( ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize ) );

  415.             fPlaybackPortList[audio_port_index] = port_id;

  416.             jack_log ( "JackNetDriver::AllocPorts() fPlaybackPortList[%d] audio_port_index = %ld fPortLatency = %ld", audio_port_index, port_id, port->GetLatency() );

  417.         }

  418.         //midi

  419.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  420.         for ( midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++ )

  421.         {

  422.             snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:out%d", fAliasName, fCaptureDriverName, midi_port_index + 1 );

  423.             snprintf ( name, sizeof ( name ) - 1, "%s:midi_capture_%d", fClientControl.fName, midi_port_index + 1 );

  424.             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_MIDI_TYPE,

  425.                              static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )

  426.             {

  427.                 jack_error ( "driver: cannot register port for %s", name );

  428.                 return -1;

  429.             }

  430.             port = fGraphManager->GetPort ( port_id );

  431.             port->SetLatency ( fEngineControl->fBufferSize );

  432.             fMidiCapturePortList[midi_port_index] = port_id;

  433.             jack_log ( "JackNetDriver::AllocPorts() fMidiCapturePortList[%d] midi_port_index = %ld fPortLatency = %ld", midi_port_index, port_id, port->GetLatency() );

  434.         }

  435. 

  436.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  437.         for ( midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++ )

  438.         {

  439.             snprintf ( alias, sizeof ( alias ) - 1, "%s:%s:in%d", fAliasName, fPlaybackDriverName, midi_port_index + 1 );

  440.             snprintf ( name, sizeof ( name ) - 1, "%s:midi_playback_%d", fClientControl.fName, midi_port_index + 1 );

  441.             if ( ( port_id = fGraphManager->AllocatePort ( fClientControl.fRefNum, name, JACK_DEFAULT_MIDI_TYPE,

  442.                              static_cast<JackPortFlags> ( port_flags ), fEngineControl->fBufferSize ) ) == NO_PORT )

  443.             {

  444.                 jack_error ( "driver: cannot register port for %s", name );

  445.                 return -1;

  446.             }

  447.             port = fGraphManager->GetPort ( port_id );

  448.             port->SetLatency ( ( fParams.fNetworkMode == 'f' ) ? 0 : fEngineControl->fBufferSize + ( ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize ) );

  449.             fMidiPlaybackPortList[midi_port_index] = port_id;

  450.             jack_log ( "JackNetDriver::AllocPorts() fMidiPlaybackPortList[%d] midi_port_index = %ld fPortLatency = %ld", midi_port_index, port_id, port->GetLatency() );

  451.         }

  452. 

  453.         return 0;

  454.     }

  455. 

  456.     int JackNetDriver::FreePorts()

  457.     {

  458.         jack_log ( "JackNetDriver::FreePorts" );

  459.         int audio_port_index;

  460.         uint midi_port_index;

  461.         for ( audio_port_index = 0; audio_port_index < fCaptureChannels; audio_port_index++ )

  462.             fGraphManager->ReleasePort ( fClientControl.fRefNum, fCapturePortList[audio_port_index] );

  463.         for ( audio_port_index = 0; audio_port_index < fPlaybackChannels; audio_port_index++ )

  464.             fGraphManager->ReleasePort ( fClientControl.fRefNum, fPlaybackPortList[audio_port_index] );

  465.         for ( midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++ )

  466.             fGraphManager->ReleasePort ( fClientControl.fRefNum, fMidiCapturePortList[midi_port_index] );

  467.         for ( midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++ )

  468.             fGraphManager->ReleasePort ( fClientControl.fRefNum, fMidiPlaybackPortList[midi_port_index] );

  469.         return 0;

  470.     }

  471. 

  472.     JackMidiBuffer* JackNetDriver::GetMidiInputBuffer ( int port_index )

  473.     {

  474.         return static_cast<JackMidiBuffer*> ( fGraphManager->GetBuffer ( fMidiCapturePortList[port_index], fEngineControl->fBufferSize ) );

  475.     }

  476. 

  477.     JackMidiBuffer* JackNetDriver::GetMidiOutputBuffer ( int port_index )

  478.     {

  479.         return static_cast<JackMidiBuffer*> ( fGraphManager->GetBuffer ( fMidiPlaybackPortList[port_index], fEngineControl->fBufferSize ) );

  480.     }

  481. 

  482.     int JackNetDriver::SetSyncPacket()

  483.     {

  484.         if ( fParams.fTransportSync )

  485.         {

  486.             //set the TransportData

  487. 

  488.             //copy to TxBuffer

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

  490.         }

  491.         return 0;

  492.     }

  493. 

  494. //***********************************network operations*************************************************************

  495. 

  496.     int JackNetDriver::Recv ( size_t size, int flags )

  497.     {

  498.         int rx_bytes = fSocket.Recv ( fRxBuffer, size, flags );

  499.         //handle errors

  500.         if ( rx_bytes == SOCKET_ERROR )

  501.         {

  502.             net_error_t error = fSocket.GetError();

  503.             //no data isn't really an error in realtime processing, so just return 0

  504.             if ( error == NET_NO_DATA )

  505.                 jack_error ( "No data, is the master still running ?" );

  506.             //if a network error occurs, this exception will restart the driver

  507.             else if ( error == NET_CONN_ERROR )

  508.             {

  509.                 jack_error ( "Connection lost." );

  510.                 throw JackDriverException();

  511.             }

  512.             else

  513.                 jack_error ( "Fatal error in receive : %s", StrError ( NET_ERROR_CODE ) );

  514.         }

  515.         return rx_bytes;

  516.     }

  517. 

  518.     int JackNetDriver::Send ( size_t size, int flags )

  519.     {

  520.         int tx_bytes = fSocket.Send ( fTxBuffer, size, flags );

  521.         //handle errors

  522.         if ( tx_bytes == SOCKET_ERROR )

  523.         {

  524.             net_error_t error = fSocket.GetError();

  525.             //if a network error occurs, this exception will restart the driver

  526.             if ( error == NET_CONN_ERROR )

  527.             {

  528.                 jack_error ( "Connection lost." );

  529.                 throw JackDriverException();

  530.             }

  531.             else

  532.                 jack_error ( "Fatal error in send : %s", StrError ( NET_ERROR_CODE ) );

  533.         }

  534.         return tx_bytes;

  535.     }

  536. 

  537. //*************************************process************************************************************************

  538. 

  539.     int JackNetDriver::Read()

  540.     {

  541.         int rx_bytes;

  542.         uint recvd_midi_pckt = 0;

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

  544.         fRxHeader.fIsLastPckt = 'n';

  545.         uint midi_port_index;

  546.         int audio_port_index;

  547. 

  548.         //buffers

  549.         for ( midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++ )

  550.             fNetMidiCaptureBuffer->SetBuffer ( midi_port_index, GetMidiInputBuffer ( midi_port_index ) );

  551.         for ( audio_port_index = 0; audio_port_index < fCaptureChannels; audio_port_index++ )

  552.             fNetAudioCaptureBuffer->SetBuffer ( audio_port_index, GetInputBuffer ( audio_port_index ) );

  553. 

  554. #ifdef JACK_MONITOR

  555.         fNetTimeMon->New();

  556. #endif

  557. 

  558.         //receive sync (launch the cycle)

  559.         do

  560.         {

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

  562.             //connection issue, send will detect it, so don't skip the cycle (return 0)

  563.             if ( rx_bytes == SOCKET_ERROR )

  564.                 return 0;

  565.         }

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

  567. 

  568.         //take the time at the beginning of the cycle

  569.         JackDriver::CycleTakeBeginTime();

  570. 

  571. #ifdef JACK_MONITOR

  572.         fCycleTimeMon->AddNew ( JackDriver::fBeginDateUst - fLastCycleBeginDate );

  573.         fCycleTimeMon->Write();

  574.         fLastCycleBeginDate = JackDriver::fBeginDateUst;

  575. #endif

  576. 

  577.         //audio, midi or sync if driver is late

  578.         if ( fParams.fSendMidiChannels || fParams.fSendAudioChannels )

  579.         {

  580.             do

  581.             {

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

  583.                 //error here, problem with recv, just skip the cycle (return -1)

  584.                 if ( rx_bytes == SOCKET_ERROR )

  585.                     return rx_bytes;

  586.                 if ( rx_bytes && ( rx_head->fDataStream == 's' ) && ( rx_head->fID == fParams.fID ) )

  587.                 {

  588.                     switch ( rx_head->fDataType )

  589.                     {

  590.                         case 'm':   //midi

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

  592.                             fRxHeader.fCycle = rx_head->fCycle;

  593.                             fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

  594.                             fNetMidiCaptureBuffer->RenderFromNetwork ( rx_head->fSubCycle, rx_bytes - sizeof ( packet_header_t ) );

  595.                             if ( ++recvd_midi_pckt == rx_head->fNMidiPckt )

  596.                                 fNetMidiCaptureBuffer->RenderToJackPorts();

  597.                             break;

  598.                         case 'a':   //audio

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

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

  601.                                 jack_error ( "Packet(s) missing..." );

  602.                             fRxHeader.fCycle = rx_head->fCycle;

  603.                             fRxHeader.fSubCycle = rx_head->fSubCycle;

  604.                             fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

  605.                             fNetAudioCaptureBuffer->RenderToJackPorts ( rx_head->fSubCycle );

  606.                             break;

  607.                         case 's':   //sync

  608.                             jack_info ( "NetDriver : driver overloaded, skipping receive." );

  609.                             fRxHeader.fCycle = rx_head->fCycle;

  610.                             return 0;

  611.                     }

  612.                 }

  613.             }

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

  615.         }

  616.         fRxHeader.fCycle = rx_head->fCycle;

  617. 

  618. #ifdef JACK_MONITOR

  619.         fNetTimeMon->Add ( ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f );

  620. #endif

  621. 

  622.         return 0;

  623.     }

  624. 

  625.     int JackNetDriver::Write()

  626.     {

  627.         uint midi_port_index;

  628.         int tx_bytes, audio_port_index;

  629. 

  630.         //tx header

  631.         if ( fEngineControl->fSyncMode )

  632.             fTxHeader.fCycle = fRxHeader.fCycle;

  633.         else

  634.             fTxHeader.fCycle++;

  635.         fTxHeader.fSubCycle = 0;

  636.         fTxHeader.fIsLastPckt = 'n';

  637. 

  638.         //buffers

  639.         for ( midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++ )

  640.             fNetMidiPlaybackBuffer->SetBuffer ( midi_port_index, GetMidiOutputBuffer ( midi_port_index ) );

  641.         for ( audio_port_index = 0; audio_port_index < fPlaybackChannels; audio_port_index++ )

  642.             fNetAudioPlaybackBuffer->SetBuffer ( audio_port_index, GetOutputBuffer ( audio_port_index ) );

  643. 

  644. #ifdef JACK_MONITOR

  645.         fNetTimeMon->Add ( ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f );

  646. #endif

  647. 

  648.         //sync

  649.         fTxHeader.fDataType = 's';

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

  651.             fTxHeader.fIsLastPckt = 'y';

  652.         fTxHeader.fPacketSize = fParams.fMtu;

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

  654.         memset ( fTxData, 0, fPayloadSize );

  655.         SetSyncPacket();

  656.         tx_bytes = Send ( fTxHeader.fPacketSize, 0 );

  657.         if ( tx_bytes == SOCKET_ERROR )

  658.             return tx_bytes;

  659. 

  660. #ifdef JACK_MONITOR

  661.         fNetTimeMon->Add ( ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f );

  662. #endif

  663. 

  664.         //midi

  665.         if ( fParams.fReturnMidiChannels )

  666.         {

  667.             fTxHeader.fDataType = 'm';

  668.             fTxHeader.fMidiDataSize = fNetMidiPlaybackBuffer->RenderFromJackPorts();

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

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

  671.             {

  672.                 fTxHeader.fSubCycle = subproc;

  673.                 if ( ( subproc == ( fTxHeader.fNMidiPckt - 1 ) ) && !fParams.fReturnAudioChannels )

  674.                     fTxHeader.fIsLastPckt = 'y';

  675.                 fTxHeader.fPacketSize = fNetMidiPlaybackBuffer->RenderToNetwork ( subproc, fTxHeader.fMidiDataSize );

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

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

  678.                 tx_bytes = Send ( fTxHeader.fPacketSize, 0 );

  679.                 if ( tx_bytes == SOCKET_ERROR )

  680.                     return tx_bytes;

  681.             }

  682.         }

  683. 

  684.         //audio

  685.         if ( fParams.fReturnAudioChannels )

  686.         {

  687.             fTxHeader.fDataType = 'a';

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

  689.             {

  690.                 fTxHeader.fSubCycle = subproc;

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

  692.                     fTxHeader.fIsLastPckt = 'y';

  693.                 fTxHeader.fPacketSize = fAudioTxLen;

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

  695.                 fNetAudioPlaybackBuffer->RenderFromJackPorts ( subproc );

  696.                 tx_bytes = Send ( fTxHeader.fPacketSize, 0 );

  697.                 if ( tx_bytes == SOCKET_ERROR )

  698.                     return tx_bytes;

  699.             }

  700.         }

  701. 

  702. #ifdef JACK_MONITOR

  703.         fNetTimeMon->AddLast ( ( ( float ) ( GetMicroSeconds() - JackDriver::fBeginDateUst ) / ( float ) fEngineControl->fPeriodUsecs ) * 100.f );

  704. #endif

  705. 

  706.         return 0;

  707.     }

  708. 

  709. //*************************************loader*******************************************************

  710. 

  711. #ifdef __cplusplus

  712.     extern "C"

  713.     {

  714. #endif

  715.         EXPORT jack_driver_desc_t* driver_get_descriptor ()

  716.         {

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

  718.             strcpy ( desc->name, "net" );

  719.             desc->nparams = 10;

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

  721. 

  722.             int i = 0;

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

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

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

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

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

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

  729. 

  730.             i++;

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

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

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

  734.             desc->params[i].value.i = 19000;

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

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

  737. 

  738.             i++;

  739.             strcpy ( desc->params[i].name, "mtu" );

  740.             desc->params[i].character = 'M';

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

  742.             desc->params[i].value.i = 1500;

  743.             strcpy ( desc->params[i].short_desc, "MTU to the master" );

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

  745. 

  746.             i++;

  747.             strcpy ( desc->params[i].name, "input_ports" );

  748.             desc->params[i].character = 'C';

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

  750.             desc->params[i].value.i = 2;

  751.             strcpy ( desc->params[i].short_desc, "Number of audio input ports" );

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

  753. 

  754.             i++;

  755.             strcpy ( desc->params[i].name, "output_ports" );

  756.             desc->params[i].character = 'P';

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

  758.             desc->params[i].value.i = 2;

  759.             strcpy ( desc->params[i].short_desc, "Number of audio output ports" );

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

  761. 

  762.             i++;

  763.             strcpy ( desc->params[i].name, "midi_in_ports" );

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

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

  766.             desc->params[i].value.i = 0;

  767.             strcpy ( desc->params[i].short_desc, "Number of midi input ports" );

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

  769. 

  770.             i++;

  771.             strcpy ( desc->params[i].name, "midi_out_ports" );

  772.             desc->params[i].character = 'o';

  773.             desc->params[i].type = JackDriverParamUInt;

  774.             desc->params[i].value.i = 0;

  775.             strcpy ( desc->params[i].short_desc, "Number of midi output ports" );

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

  777. 

  778.             i++;

  779.             strcpy ( desc->params[i].name, "client_name" );

  780.             desc->params[i].character = 'n';

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

  782.             strcpy ( desc->params[i].value.str, "'hostname'" );

  783.             strcpy ( desc->params[i].short_desc, "Name of the jack client" );

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

  785. 

  786.             i++;

  787.             strcpy ( desc->params[i].name, "transport_sync" );

  788.             desc->params[i].character  = 't';

  789.             desc->params[i].type = JackDriverParamUInt;

  790.             desc->params[i].value.ui = 1U;

  791.             strcpy ( desc->params[i].short_desc, "Sync transport with master's" );

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

  793. 

  794.             i++;

  795.             strcpy ( desc->params[i].name, "network_mode" );

  796.             desc->params[i].character  = 'f';

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

  798.             strcpy ( desc->params[i].value.str, "" );

  799.             strcpy ( desc->params[i].short_desc, "Fast mode allows a zero latency transmission." );

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

  801. 

  802.             return desc;

  803.         }

  804. 

  805.         EXPORT Jack::JackDriverClientInterface* driver_initialize ( Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params )

  806.         {

  807.             if ( SocketAPIInit() < 0 )

  808.             {

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

  810.                 return NULL;

  811.             }

  812.             const char* multicast_ip = DEFAULT_MULTICAST_IP;

  813.             char name[JACK_CLIENT_NAME_SIZE];

  814.             GetHostName ( name, JACK_CLIENT_NAME_SIZE );

  815.             int udp_port = DEFAULT_PORT;

  816.             int mtu = 1500;

  817.             uint transport_sync = 1;

  818.             jack_nframes_t period_size = 128;

  819.             jack_nframes_t sample_rate = 48000;

  820.             int audio_capture_ports = 2;

  821.             int audio_playback_ports = 2;

  822.             int midi_input_ports = 0;

  823.             int midi_output_ports = 0;

  824.             bool monitor = false;

  825.             char network_mode = 'n';

  826. 

  827.             const JSList* node;

  828.             const jack_driver_param_t* param;

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

  830.             {

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

  832.                 switch ( param->character )

  833.                 {

  834.                     case 'a' :

  835.                         multicast_ip = strdup ( param->value.str );

  836.                         break;

  837.                     case 'p':

  838.                         udp_port = param->value.ui;

  839.                         break;

  840.                     case 'M':

  841.                         mtu = param->value.i;

  842.                         break;

  843.                     case 'C':

  844.                         audio_capture_ports = param->value.i;

  845.                         break;

  846.                     case 'P':

  847.                         audio_playback_ports = param->value.i;

  848.                         break;

  849.                     case 'i':

  850.                         midi_input_ports = param->value.i;

  851.                         break;

  852.                     case 'o':

  853.                         midi_output_ports = param->value.i;

  854.                         break;

  855.                     case 'n' :

  856.                         strncpy ( name, param->value.str, JACK_CLIENT_NAME_SIZE );

  857.                         break;

  858.                     case 't' :

  859.                         transport_sync = param->value.ui;

  860.                         break;

  861.                     case 'f' :

  862.                         network_mode = 'f';

  863.                         break;

  864.                 }

  865.             }

  866. 

  867.             Jack::JackDriverClientInterface* driver = new Jack::JackWaitThreadedDriver (

  868.                 new Jack::JackNetDriver ( "system", "net_pcm", engine, table, multicast_ip, udp_port, mtu,

  869.                                           midi_input_ports, midi_output_ports, name, transport_sync, network_mode ) );

  870.             if ( driver->Open ( period_size, sample_rate, 1, 1, audio_capture_ports, audio_playback_ports,

  871.                                 monitor, "from_master_", "to_master_", 0, 0 ) == 0 )

  872.                 return driver;

  873. 

  874.             delete driver;

  875.             return NULL;

  876.         }

  877. 

  878. #ifdef __cplusplus

  879.     }

  880. #endif

  881. }