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

421 lines
14KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2008 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 "JackNetAdapter.h"

  21. 

  22. #define DEFAULT_MULTICAST_IP "225.3.19.154"

  23. #define DEFAULT_PORT 19000

  24. 

  25. namespace Jack

  26. {

  27. 

  28.     JackNetAdapter::JackNetAdapter ( jack_nframes_t buffer_size, jack_nframes_t sample_rate, const JSList* params )

  29.             : JackAudioAdapterInterface ( buffer_size, sample_rate ), fThread ( this )

  30.     {

  31.         jack_log ( "JackNetAdapter::JackNetAdapter" );

  32. 

  33.         if ( SocketAPIInit() < 0 )

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

  35. 

  36.         //global parametering

  37.         fMulticastIP = new char[16];

  38.         strcpy ( fMulticastIP, DEFAULT_MULTICAST_IP );

  39.         fSocket.SetPort ( DEFAULT_PORT );

  40.         GetHostName ( fParams.fName, JACK_CLIENT_NAME_SIZE );

  41.         fSocket.GetName ( fParams.fSlaveNetName );

  42.         fParams.fMtu = 1500;

  43.         fParams.fTransportSync = 1;

  44.         fParams.fSendAudioChannels = 2;

  45.         fParams.fReturnAudioChannels = 2;

  46.         fParams.fSendMidiChannels = 0;

  47.         fParams.fReturnMidiChannels = 0;

  48.         fParams.fSampleRate = 48000;

  49.         fParams.fPeriodSize = 128;

  50.         fParams.fSlaveSyncMode = 1;

  51.         fParams.fNetworkMode = 'n';

  52. 

  53.         //options parsing

  54.         const JSList* node;

  55.         const jack_driver_param_t* param;

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

  57.         {

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

  59.             switch ( param->character )

  60.             {

  61.                 case 'a' :

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

  63.                     break;

  64.                 case 'p':

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

  66.                     break;

  67.                 case 'M':

  68.                     fParams.fMtu = param->value.i;

  69.                     break;

  70.                 case 'C':

  71.                     fParams.fSendAudioChannels = param->value.i;

  72.                     break;

  73.                 case 'P':

  74.                     fParams.fReturnAudioChannels = param->value.i;

  75.                     break;

  76.                 case 'n' :

  77.                     strncpy ( fParams.fName, param->value.str, JACK_CLIENT_NAME_SIZE );

  78.                     break;

  79.                 case 't' :

  80.                     fParams.fTransportSync = param->value.ui;

  81.                     break;

  82.                 case 'm' :

  83.                     if ( strcmp ( param->value.str, "normal" ) == 0 )

  84.                         fParams.fNetworkMode = 'n';

  85.                     else if ( strcmp ( param->value.str, "slow" ) == 0 )

  86.                         fParams.fNetworkMode = 's';

  87.                     else if ( strcmp ( param->value.str, "fast" ) == 0 )

  88.                         fParams.fNetworkMode = 'f';

  89.                     else

  90.                         jack_error ( "Unknown network mode, using 'normal' mode." );

  91.                     break;

  92.                 case 'S' :

  93.                     fParams.fSlaveSyncMode = 1;

  94.             }

  95.         }

  96. 

  97.         fCaptureChannels = fParams.fSendAudioChannels;

  98.         fPlaybackChannels = fParams.fReturnAudioChannels;

  99.         fSoftCaptureBuffer = NULL;

  100.         fSoftPlaybackBuffer = NULL;

  101.     }

  102. 

  103.     JackNetAdapter::~JackNetAdapter()

  104.     {

  105.         int port_index;

  106.         for ( port_index = 0; port_index < fCaptureChannels; port_index++ )

  107.             delete[] fSoftCaptureBuffer[port_index];

  108.         delete[] fSoftCaptureBuffer;

  109.         for ( port_index = 0; port_index < fPlaybackChannels; port_index++ )

  110.             delete[] fSoftPlaybackBuffer[port_index];

  111.         delete[] fSoftPlaybackBuffer;

  112.     }

  113. 

  114.     int JackNetAdapter::Open()

  115.     {

  116.         jack_log ( "JackNetAdapter::Open()" );

  117. 

  118.         int port_index;

  119. 

  120.         //display some additional infos

  121.         jack_info ( "Net adapter started in %s mode %s Master's transport sync.",

  122.                     ( fParams.fSlaveSyncMode ) ? "sync" : "async", ( fParams.fTransportSync ) ? "with" : "without" );

  123. 

  124.         //init network connection

  125.         if ( !JackNetSlaveInterface::Init() )

  126.             return -1;

  127. 

  128.         //then set global parameters

  129.         SetParams();

  130. 

  131.         //set buffers

  132.         fSoftCaptureBuffer = new sample_t*[fCaptureChannels];

  133.         for ( port_index = 0; port_index < fCaptureChannels; port_index++ )

  134.         {

  135.             fSoftCaptureBuffer[port_index] = new sample_t[fParams.fPeriodSize];

  136.             fNetAudioCaptureBuffer->SetBuffer ( port_index, fSoftCaptureBuffer[port_index] );

  137.         }

  138.         fSoftPlaybackBuffer = new sample_t*[fPlaybackChannels];

  139.         for ( port_index = 0; port_index < fCaptureChannels; port_index++ )

  140.         {

  141.             fSoftPlaybackBuffer[port_index] = new sample_t[fParams.fPeriodSize];

  142.             fNetAudioPlaybackBuffer->SetBuffer ( port_index, fSoftPlaybackBuffer[port_index] );

  143.         }

  144. 

  145.         fThread.AcquireRealTime ( 85 );

  146. 

  147.         return fThread.StartSync();

  148.     }

  149. 

  150.     int JackNetAdapter::Close()

  151.     {

  152.         fSocket.Close();

  153.         return 0;

  154.     }

  155. 

  156.     int JackNetAdapter::SetBufferSize ( jack_nframes_t buffer_size )

  157.     {

  158.         fParams.fPeriodSize = buffer_size;

  159.         return 0;

  160.     }

  161. 

  162.     bool JackNetAdapter::Init()

  163.     {

  164.         jack_info ( "Starting NetAdapter." );

  165.         return true;

  166.     }

  167. 

  168.     bool JackNetAdapter::Execute()

  169.     {

  170.         //the sync mode is the equivalent of driver sync mode : data are sent back right after being computed

  171.         //TODO : verify async mode is appropriate here, because of the ringbuffer usage

  172.         switch ( fParams.fSlaveSyncMode )

  173.         {

  174.             case true :

  175.                 return ProcessSync();

  176.             case false :

  177.                 return ProcessAsync();

  178.         }

  179.         return true;

  180.     }

  181. 

  182.     bool JackNetAdapter::ProcessSync()

  183.     {

  184.         bool failure = false;

  185.         int port_index;

  186. 

  187.         //receive

  188.         if ( SyncRecv() == SOCKET_ERROR )

  189.             return true;

  190. 

  191.         if ( DataRecv() == SOCKET_ERROR )

  192.             return false;

  193. 

  194.         //resample

  195.         jack_nframes_t time1, time2;

  196.         ResampleFactor ( time1, time2 );

  197. 

  198.         for ( port_index = 0; port_index < fCaptureChannels; port_index++ )

  199.         {

  200.             fCaptureRingBuffer[port_index]->SetRatio ( time1, time2 );

  201.             if ( fCaptureRingBuffer[port_index]->WriteResample ( fSoftCaptureBuffer[port_index], fBufferSize ) < fBufferSize )

  202.                 failure = true;

  203.         }

  204. 

  205.         for ( port_index = 0; port_index < fPlaybackChannels; port_index++ )

  206.         {

  207.             fPlaybackRingBuffer[port_index]->SetRatio ( time2, time1 );

  208.             if ( fPlaybackRingBuffer[port_index]->ReadResample ( fSoftPlaybackBuffer[port_index], fBufferSize ) < fBufferSize )

  209.                 failure = true;

  210.         }

  211. 

  212.         //send

  213.         if ( SyncSend() == SOCKET_ERROR )

  214.             return false;

  215. 

  216.         if ( DataSend() == SOCKET_ERROR )

  217.             return false;

  218. 

  219.         if ( failure )

  220.         {

  221.             jack_error ( "JackNetAdapter::Execute ringbuffer failure...reset." );

  222.             ResetRingBuffers();

  223.         }

  224. 

  225.         return true;

  226.     }

  227. 

  228.     bool JackNetAdapter::ProcessAsync()

  229.     {

  230.         bool failure = false;

  231.         int port_index;

  232. 

  233.         //receive

  234.         if ( SyncRecv() == SOCKET_ERROR )

  235.             return true;

  236. 

  237.         if ( DataRecv() == SOCKET_ERROR )

  238.             return false;

  239. 

  240.         //send

  241.         if ( SyncSend() == SOCKET_ERROR )

  242.             return false;

  243. 

  244.         if ( DataSend() == SOCKET_ERROR )

  245.             return false;

  246. 

  247.         if ( failure )

  248.         {

  249.             jack_error ( "JackNetAdapter::Execute ringbuffer failure...reset." );

  250.             ResetRingBuffers();

  251.         }

  252. 

  253.         //resample

  254.         jack_nframes_t time1, time2;

  255.         ResampleFactor ( time1, time2 );

  256. 

  257.         for ( port_index = 0; port_index < fCaptureChannels; port_index++ )

  258.         {

  259.             fCaptureRingBuffer[port_index]->SetRatio ( time1, time2 );

  260.             if ( fCaptureRingBuffer[port_index]->WriteResample ( fSoftCaptureBuffer[port_index], fBufferSize ) < fBufferSize )

  261.                 failure = true;

  262.         }

  263. 

  264.         for ( port_index = 0; port_index < fPlaybackChannels; port_index++ )

  265.         {

  266.             fPlaybackRingBuffer[port_index]->SetRatio ( time2, time1 );

  267.             if ( fPlaybackRingBuffer[port_index]->ReadResample ( fSoftPlaybackBuffer[port_index], fBufferSize ) < fBufferSize )

  268.                 failure = true;

  269.         }

  270. 

  271.         return true;

  272.     }

  273. 

  274. } // namespace Jack

  275. 

  276. #ifdef __cplusplus

  277. extern "C"

  278. {

  279. #endif

  280. 

  281. #include "driver_interface.h"

  282. #include "JackAudioAdapter.h"

  283. 

  284.     using namespace Jack;

  285. 

  286.     EXPORT jack_driver_desc_t* jack_get_descriptor()

  287.     {

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

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

  290.         desc->nparams = 9;

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

  292. 

  293.         int i = 0;

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

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

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

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

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

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

  300. 

  301.         i++;

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

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

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

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

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

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

  308. 

  309.         i++;

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

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

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

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

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

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

  316. 

  317.         i++;

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

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

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

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

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

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

  324. 

  325.         i++;

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

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

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

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

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

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

  332. 

  333.         i++;

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

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

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

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

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

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

  340. 

  341.         i++;

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

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

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

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

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

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

  348. 

  349.         i++;

  350.         strcpy ( desc->params[i].name, "mode" );

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

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

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

  354.         strcpy ( desc->params[i].short_desc, "Slow, Normal or Fast mode." );

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

  356. 

  357.         i++;

  358.         strcpy ( desc->params[i].name, "sync_mode" );

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

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

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

  362.         strcpy ( desc->params[i].short_desc, "Sync mode (same as driver's sync mode) ?" );

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

  364. 

  365.         return desc;

  366.     }

  367. 

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

  369.     {

  370.         jack_log ( "Loading netadapter" );

  371. 

  372.         Jack::JackAudioAdapter* adapter;

  373.         jack_nframes_t buffer_size = jack_get_buffer_size ( jack_client );

  374.         jack_nframes_t sample_rate = jack_get_sample_rate ( jack_client );

  375. 

  376.         adapter = new Jack::JackAudioAdapter ( jack_client, new Jack::JackNetAdapter ( buffer_size, sample_rate, params ) );

  377.         assert ( adapter );

  378. 

  379.         if ( adapter->Open() == 0 )

  380.         {

  381.             return 0;

  382.         }

  383.         else

  384.         {

  385.             delete adapter;

  386.             return 1;

  387.         }

  388.     }

  389. 

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

  391.     {

  392.         JSList* params = NULL;

  393.         jack_driver_desc_t *desc = jack_get_descriptor();

  394. 

  395.         JackArgParser parser ( load_init );

  396. 

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

  398.         {

  399.             if ( parser.ParseParams ( desc, &params ) != 0 )

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

  401.         }

  402. 

  403.         return jack_internal_initialize ( jack_client, params );

  404.     }

  405. 

  406.     EXPORT void jack_finish ( void* arg )

  407.     {

  408.         Jack::JackAudioAdapter* adapter = static_cast<Jack::JackAudioAdapter*> ( arg );

  409. 

  410.         if ( adapter )

  411.         {

  412.             jack_log ( "Unloading netadapter" );

  413.             adapter->Close();

  414.             delete adapter;

  415.         }

  416.     }

  417. 

  418. #ifdef __cplusplus

  419. }

  420. #endif