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

744 lines
30KB
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. namespace Jack

  34. {

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

  36.                                    const char* ip, int port, int mtu, int midi_input_ports, int midi_output_ports, const char* net_name, uint transport_sync )

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

  38.     {

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

  40.         strcpy ( fMulticastIP, ip );

  41.         fParams.fMtu = mtu;

  42.         fParams.fSendMidiChannels = midi_input_ports;

  43.         fParams.fReturnMidiChannels = midi_output_ports;

  44.         strcpy ( fParams.fName, net_name );

  45.         fSocket.GetName ( fParams.fSlaveNetName );

  46.         fParams.fTransportSync = transport_sync;

  47.     }

  48. 

  49.     JackNetDriver::~JackNetDriver()

  50.     {

  51.         fSocket.Close();

  52.         SocketAPIEnd();

  53.         delete fNetAudioCaptureBuffer;

  54.         delete fNetAudioPlaybackBuffer;

  55.         delete fNetMidiCaptureBuffer;

  56.         delete fNetMidiPlaybackBuffer;

  57.         delete[] fTxBuffer;

  58.         delete[] fRxBuffer;

  59.         delete[] fMulticastIP;

  60.         delete[] fMidiCapturePortList;

  61.         delete[] fMidiPlaybackPortList;

  62.     }

  63. 

  64. //*************************************initialization***********************************************************************

  65. 

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

  67.                               int inchannels, int outchannels, bool monitor,

  68.                               const char* capture_driver_name, const char* playback_driver_name,

  69.                               jack_nframes_t capture_latency, jack_nframes_t playback_latency )

  70.     {

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

  72.                                           capture_driver_name, playback_driver_name, capture_latency, playback_latency );

  73.         fEngineControl->fPeriod = 0;

  74.         fEngineControl->fComputation = 500 * 1000;

  75.         fEngineControl->fConstraint = 500 * 1000;

  76.         return res;

  77.     }

  78. 

  79.     int JackNetDriver::Attach()

  80.     {

  81.         return 0;

  82.     }

  83. 

  84.     int JackNetDriver::Detach()

  85.     {

  86.         return 0;

  87.     }

  88. 

  89.     bool JackNetDriver::Init()

  90.     {

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

  92. 

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

  94.         if ( fSocket.IsSocket() )

  95.             Restart();

  96. 

  97.         //set the parameters to send

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

  99.         fParams.fProtocolVersion = 'a';

  100.         SetPacketType ( &fParams, SLAVE_AVAILABLE );

  101.         fParams.fSendAudioChannels = fCaptureChannels;

  102.         fParams.fReturnAudioChannels = fPlaybackChannels;

  103. 

  104.         //is transport sync ?

  105.         if ( fParams.fTransportSync )

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

  107. 

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

  109.         net_status_t status;

  110.         do

  111.         {

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

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

  114.             do

  115.             {

  116.                 status = GetNetMaster();

  117.                 if ( status == NET_SOCKET_ERROR )

  118.                     return false;

  119.             }

  120.             while ( status != NET_CONNECTED );

  121. 

  122.             //then tell the master we are ready

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

  124.             status = SendMasterStartSync();

  125.             if ( status == NET_ERROR )

  126.                 return false;

  127.         }

  128.         while ( status != NET_ROLLING );

  129. 

  130.         //driver parametering

  131.         if ( SetParams() )

  132.         {

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

  134.             return false;

  135.         }

  136. 

  137.         //init done, display parameters

  138.         SessionParamsDisplay ( &fParams );

  139. 

  140.         return true;

  141.     }

  142. 

  143.     net_status_t JackNetDriver::GetNetMaster()

  144.     {

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

  146.         //utility

  147.         session_params_t params;

  148.         int ms_timeout = 2000;

  149.         int rx_bytes = 0;

  150. 

  151.         //socket

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

  153.         {

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

  155.             return NET_SOCKET_ERROR;

  156.         }

  157. 

  158.         //bind the socket

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

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

  161. 

  162.         //timeout on receive

  163.         if ( fSocket.SetTimeOut ( ms_timeout ) == SOCKET_ERROR )

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

  165. 

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

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

  168.         do

  169.         {

  170.             //send 'available'

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

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

  173.             //filter incoming packets : don't exit while receiving wrong packets

  174.             do

  175.             {

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

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

  178.                 {

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

  180.                     return NET_RECV_ERROR;

  181.                 }

  182.             }

  183.             while ( ( rx_bytes > 0 )  && strcmp ( params.fPacketType, fParams.fPacketType ) );

  184.         }

  185.         while ( ( GetPacketType ( &params ) != SLAVE_SETUP ) );

  186. 

  187.         //connect the socket

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

  189.         {

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

  191.             return NET_CONNECT_ERROR;

  192.         }

  193. 

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

  195.         fParams = params;

  196. 

  197.         return NET_CONNECTED;

  198.     }

  199. 

  200.     net_status_t JackNetDriver::SendMasterStartSync()

  201.     {

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

  203.         //tell the master to start

  204.         SetPacketType ( &fParams, START_MASTER );

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

  206.         {

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

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

  209.         }

  210.         return NET_ROLLING;

  211.     }

  212. 

  213.     void JackNetDriver::Restart()

  214.     {

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

  216.         delete[] fTxBuffer;

  217.         delete[] fRxBuffer;

  218.         delete fNetAudioCaptureBuffer;

  219.         delete fNetAudioPlaybackBuffer;

  220.         delete fNetMidiCaptureBuffer;

  221.         delete fNetMidiPlaybackBuffer;

  222.         FreePorts();

  223.         delete[] fMidiCapturePortList;

  224.         delete[] fMidiPlaybackPortList;

  225.         fTxBuffer = NULL;

  226.         fRxBuffer = NULL;

  227.         fNetAudioCaptureBuffer = NULL;

  228.         fNetAudioPlaybackBuffer = NULL;

  229.         fNetMidiCaptureBuffer = NULL;

  230.         fNetMidiPlaybackBuffer = NULL;

  231.         fMidiCapturePortList = NULL;

  232.         fMidiPlaybackPortList = NULL;

  233.     }

  234. 

  235.     int JackNetDriver::SetParams()

  236.     {

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

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

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

  240. 

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

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

  243. 

  244.         //allocate midi ports lists

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

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

  247. 

  248.         //register jack ports

  249.         if ( AllocPorts() != 0 )

  250.         {

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

  252.             return -1;

  253.         }

  254. 

  255.         //TX header init

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

  257.         fTxHeader.fDataStream = 'r';

  258.         fTxHeader.fID = fParams.fID;

  259.         fTxHeader.fCycle = 0;

  260.         fTxHeader.fSubCycle = 0;

  261.         fTxHeader.fMidiDataSize = 0;

  262.         fTxHeader.fBitdepth = fParams.fBitdepth;

  263. 

  264.         //RX header init

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

  266.         fRxHeader.fDataStream = 's';

  267.         fRxHeader.fID = fParams.fID;

  268.         fRxHeader.fCycle = 0;

  269.         fRxHeader.fSubCycle = 0;

  270.         fRxHeader.fMidiDataSize = 0;

  271.         fRxHeader.fBitdepth = fParams.fBitdepth;

  272. 

  273.         //network buffers

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

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

  276. 

  277.         //net audio/midi buffers

  278.         fTxData = fTxBuffer + sizeof ( packet_header_t );

  279.         fRxData = fRxBuffer + sizeof ( packet_header_t );

  280. 

  281.         //midi net buffers

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

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

  284. 

  285.         //audio net buffers

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

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

  288. 

  289.         //audio netbuffer length

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

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

  292. 

  293. 		//payload size

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

  295. 

  296.         return 0;

  297.     }

  298. 

  299.     int JackNetDriver::AllocPorts()

  300.     {

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

  302.         JackPort* port;

  303.         jack_port_id_t port_id;

  304.         char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  305.         char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  306.         unsigned long port_flags;

  307.         int audio_port_index;

  308.         uint midi_port_index;

  309. 

  310.         //audio

  311.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  313.         {

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

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

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

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

  318.             {

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

  320.                 return -1;

  321.             }

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

  323.             port->SetAlias ( alias );

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

  325.             fCapturePortList[audio_port_index] = port_id;

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

  327.         }

  328.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  330.         {

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

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

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

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

  335.             {

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

  337.                 return -1;

  338.             }

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

  340.             port->SetAlias ( alias );

  341.             port->SetLatency ( fEngineControl->fBufferSize + ( ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize ) );

  342.             fPlaybackPortList[audio_port_index] = port_id;

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

  344.         }

  345.         //midi

  346.         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

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

  348.         {

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

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

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

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

  353.             {

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

  355.                 return -1;

  356.             }

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

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

  359.             fMidiCapturePortList[midi_port_index] = port_id;

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

  361.         }

  362. 

  363.         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

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

  365.         {

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

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

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

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

  370.             {

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

  372.                 return -1;

  373.             }

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

  375.             port->SetLatency ( fEngineControl->fBufferSize + ( ( fEngineControl->fSyncMode ) ? 0 : fEngineControl->fBufferSize ) );

  376.             fMidiPlaybackPortList[midi_port_index] = port_id;

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

  378.         }

  379. 

  380.         return 0;

  381.     }

  382. 

  383.     int JackNetDriver::FreePorts()

  384.     {

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

  386.         int audio_port_index;

  387.         uint midi_port_index;

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

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

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

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

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

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

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

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

  396.         return 0;

  397.     }

  398. 

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

  400.     {

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

  402.     }

  403. 

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

  405.     {

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

  407.     }

  408. 

  409.     int JackNetDriver::SetSyncPacket()

  410.     {

  411.         if ( fParams.fTransportSync )

  412.         {

  413.             //set the TransportData

  414. 

  415.             //copy to TxBuffer

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

  417.         }

  418.         return 0;

  419.     }

  420. 

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

  422.     {

  423.         int rx_bytes;

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

  425.         {

  426.             net_error_t error = fSocket.GetError();

  427.             if ( error == NET_NO_DATA )

  428.             {

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

  430.                 return 0;

  431.             }

  432.             else if ( error == NET_CONN_ERROR )

  433.             {

  434.                 throw JackDriverException ( "Connection lost." );

  435.             }

  436.             else

  437.             {

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

  439.                 return 0;

  440.             }

  441.         }

  442.         return rx_bytes;

  443.     }

  444. 

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

  446.     {

  447.         int tx_bytes;

  448.         if ( ( tx_bytes = fSocket.Send ( fTxBuffer, size, flags ) ) == SOCKET_ERROR )

  449.         {

  450.             net_error_t error = fSocket.GetError();

  451.             if ( error == NET_CONN_ERROR )

  452.                 throw JackDriverException ( "Connection lost." );

  453.             else

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

  455.         }

  456.         return tx_bytes;

  457.     }

  458. 

  459. //*************************************process************************************************************************

  460. 

  461.     int JackNetDriver::Read()

  462.     {

  463.         int rx_bytes;

  464.         uint recvd_midi_pckt = 0;

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

  466.         fRxHeader.fIsLastPckt = 'n';

  467.         uint midi_port_index;

  468.         int audio_port_index;

  469. 

  470.         //buffers

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

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

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

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

  475. 

  476.         //receive sync (launch the cycle)

  477.         do

  478.         {

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

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

  481.                 return rx_bytes;

  482.         }

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

  484. 

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

  486.         JackDriver::CycleTakeBeginTime();

  487. 

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

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

  490.         {

  491.             do

  492.             {

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

  494.                     return rx_bytes;

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

  496.                 {

  497.                     switch ( rx_head->fDataType )

  498.                     {

  499.                     case 'm':	//midi

  500.                         rx_bytes = Recv ( rx_bytes, 0 );

  501.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

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

  504.                             fNetMidiCaptureBuffer->RenderToJackPorts();

  505.                         break;

  506.                     case 'a':	//audio

  507.                         rx_bytes = Recv ( fAudioRxLen, 0 );

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

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

  510.                         fRxHeader.fCycle = rx_head->fCycle;

  511.                         fRxHeader.fSubCycle = rx_head->fSubCycle;

  512.                         fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;

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

  514.                         break;

  515.                     case 's':	//sync

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

  517.                         fRxHeader.fCycle = rx_head->fCycle;

  518.                         return 0;

  519.                     }

  520.                 }

  521.             }

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

  523.         }

  524.         fRxHeader.fCycle = rx_head->fCycle;

  525.         return 0;

  526.     }

  527. 

  528.     int JackNetDriver::Write()

  529.     {

  530.         int tx_bytes, copy_size;

  531.         fTxHeader.fCycle = fRxHeader.fCycle;

  532.         fTxHeader.fSubCycle = 0;

  533.         fTxHeader.fIsLastPckt = 'n';

  534.         uint midi_port_index;

  535.         int audio_port_index;

  536. 

  537.         //buffers

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

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

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

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

  542. 

  543.         //sync

  544.         fTxHeader.fDataType = 's';

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

  546.             fTxHeader.fIsLastPckt = 'y';

  547.         memset ( fTxData, 0, fPayloadSize );

  548.         SetSyncPacket();

  549.         tx_bytes = Send ( fParams.fMtu, 0 );

  550. 

  551.         //midi

  552.         if ( fParams.fReturnMidiChannels )

  553.         {

  554.             fTxHeader.fDataType = 'm';

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

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

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

  558.             {

  559.                 fTxHeader.fSubCycle = subproc;

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

  561.                     fTxHeader.fIsLastPckt = 'y';

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

  563.                 copy_size = fNetMidiPlaybackBuffer->RenderToNetwork ( subproc, fTxHeader.fMidiDataSize );

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

  565.             }

  566.         }

  567. 

  568.         //audio

  569.         if ( fParams.fReturnAudioChannels )

  570.         {

  571.             fTxHeader.fDataType = 'a';

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

  573.             {

  574.                 fTxHeader.fSubCycle = subproc;

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

  576.                     fTxHeader.fIsLastPckt = 'y';

  577.                 fNetAudioPlaybackBuffer->RenderFromJackPorts ( subproc );

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

  579.                 tx_bytes = Send ( fAudioTxLen, 0 );

  580.             }

  581.         }

  582.         return 0;

  583.     }

  584. 

  585. //*************************************loader*******************************************************

  586. 

  587. #ifdef __cplusplus

  588.     extern "C"

  589.     {

  590. #endif

  591.         EXPORT jack_driver_desc_t* driver_get_descriptor ()

  592.         {

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

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

  595.             desc->nparams = 9;

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

  597. 

  598.             int i = 0;

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

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

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

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

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

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

  605. 

  606.             i++;

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

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

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

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

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

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

  613. 

  614.             i++;

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

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

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

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

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

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

  621. 

  622.             i++;

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

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

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

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

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

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

  629. 

  630.             i++;

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

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

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

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

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

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

  637. 

  638.             i++;

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

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

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

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

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

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

  645. 

  646.             i++;

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

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

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

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

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

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

  653. 

  654.             i++;

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

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

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

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

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

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

  661. 

  662.             i++;

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

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

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

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

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

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

  669. 

  670.             return desc;

  671.         }

  672. 

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

  674.         {

  675.             if ( SocketAPIInit() < 0 )

  676.             {

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

  678.                 return NULL;

  679.             }

  680.             const char* multicast_ip = DEFAULT_MULTICAST_IP;

  681.             char name[JACK_CLIENT_NAME_SIZE];

  682.             GetHostName ( name, JACK_CLIENT_NAME_SIZE );

  683.             int udp_port = DEFAULT_PORT;

  684.             int mtu = 1500;

  685.             uint transport_sync = 1;

  686.             jack_nframes_t period_size = 128;

  687.             jack_nframes_t sample_rate = 48000;

  688.             int audio_capture_ports = 2;

  689.             int audio_playback_ports = 2;

  690.             int midi_input_ports = 0;

  691.             int midi_output_ports = 0;

  692.             bool monitor = false;

  693. 

  694.             const JSList* node;

  695.             const jack_driver_param_t* param;

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

  697.             {

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

  699.                 switch ( param->character )

  700.                 {

  701.                 case 'a' :

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

  703.                     break;

  704.                 case 'p':

  705.                     udp_port = param->value.ui;

  706.                     break;

  707.                 case 'M':

  708.                     mtu = param->value.i;

  709.                     break;

  710.                 case 'C':

  711.                     audio_capture_ports = param->value.i;

  712.                     break;

  713.                 case 'P':

  714.                     audio_playback_ports = param->value.i;

  715.                     break;

  716.                 case 'i':

  717.                     midi_input_ports = param->value.i;

  718.                     break;

  719.                 case 'o':

  720.                     midi_output_ports = param->value.i;

  721.                     break;

  722.                 case 'n' :

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

  724.                 case 't' :

  725.                     transport_sync = param->value.ui;

  726.                 }

  727.             }

  728. 

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

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

  731.                                           midi_input_ports, midi_output_ports, name, transport_sync ) );

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

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

  734.                 return driver;

  735. 

  736.             delete driver;

  737.             return NULL;

  738.         }

  739. 

  740. #ifdef __cplusplus

  741.     }

  742. #endif

  743. }