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.
1275 Commits
8 Branches
63MB
Tree: bfdf50d52d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'bfdf50d52d'
${ noResults }
jack2/windows/portaudio/JackPortAudioDriver.cpp

498 lines
18KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2004-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. #if defined(HAVE_CONFIG_H)

  21. #include "config.h"

  22. #endif

  23. 

  24. #ifdef WIN32

  25. #pragma warning (disable : 4786)

  26. #endif

  27. 

  28. #include "JackDriverLoader.h"

  29. #include "driver_interface.h"

  30. #include "JackPortAudioDriver.h"

  31. #include "JackEngineControl.h"

  32. #include "JackError.h"

  33. #include "JackTime.h"

  34. #include "JackCompilerDeps.h"

  35. #include <iostream>

  36. #include <assert.h>

  37. 

  38. using namespace std;

  39. 

  40. namespace Jack

  41. {

  42.     int JackPortAudioDriver::Render(const void* inputBuffer, void* outputBuffer,

  43.                                     unsigned long framesPerBuffer,

  44.                                     const PaStreamCallbackTimeInfo* timeInfo,

  45.                                     PaStreamCallbackFlags statusFlags,

  46.                                     void* userData)

  47.     {

  48.         JackPortAudioDriver* driver = (JackPortAudioDriver*)userData;

  49.         driver->fInputBuffer = (float**)inputBuffer;

  50.         driver->fOutputBuffer = (float**)outputBuffer;

  51.         // Setup threadded based log function

  52.         set_threaded_log_function();

  53.         driver->CycleTakeBeginTime();

  54.         return (driver->Process() == 0) ? paContinue : paAbort;

  55.     }

  56. 

  57.     int JackPortAudioDriver::Read()

  58.     {

  59.         for (int i = 0; i < fCaptureChannels; i++)

  60.             memcpy(GetInputBuffer(i), fInputBuffer[i], sizeof(float) * fEngineControl->fBufferSize);

  61.         return 0;

  62.     }

  63. 

  64.     int JackPortAudioDriver::Write()

  65.     {

  66.         for (int i = 0; i < fPlaybackChannels; i++)

  67.             memcpy(fOutputBuffer[i], GetOutputBuffer(i), sizeof(float) * fEngineControl->fBufferSize);

  68.         return 0;

  69.     }

  70. 

  71.     int JackPortAudioDriver::Open(jack_nframes_t buffer_size,

  72.                                   jack_nframes_t samplerate,

  73.                                   bool capturing,

  74.                                   bool playing,

  75.                                   int inchannels,

  76.                                   int outchannels,

  77.                                   bool monitor,

  78.                                   const char* capture_driver_uid,

  79.                                   const char* playback_driver_uid,

  80.                                   jack_nframes_t capture_latency,

  81.                                   jack_nframes_t playback_latency)

  82.     {

  83.         PaError err = paNoError;

  84.         PaStreamParameters inputParameters;

  85.         PaStreamParameters outputParameters;

  86.         int in_max = 0;

  87.         int out_max = 0;

  88. 

  89.         jack_log("JackPortAudioDriver::Open nframes = %ld in = %ld out = %ld capture name = %s playback name = %s samplerate = %ld",

  90.                  buffer_size, inchannels, outchannels, capture_driver_uid, playback_driver_uid, samplerate);

  91. 

  92.         // Generic JackAudioDriver Open

  93.         if (JackAudioDriver::Open(buffer_size, samplerate, capturing, playing, inchannels, outchannels, monitor, capture_driver_uid, playback_driver_uid, capture_latency, playback_latency) != 0)

  94.             return -1;

  95. 

  96.         //get devices

  97.         if (capturing)

  98.         {

  99.             if (fPaDevices->GetInputDeviceFromName(capture_driver_uid, fInputDevice, in_max) < 0)

  100.                 goto error;

  101.         }

  102.         if (playing)

  103.         {

  104.             if (fPaDevices->GetOutputDeviceFromName(playback_driver_uid, fOutputDevice, out_max) < 0)

  105.                 goto error;

  106.         }

  107. 

  108.         //default channels number required

  109.         if (inchannels == 0)

  110.         {

  111.             jack_log("JackPortAudioDriver::Open setup max in channels = %ld", in_max);

  112.             inchannels = in_max;

  113.         }

  114.         if (outchannels == 0)

  115.         {

  116.             jack_log("JackPortAudioDriver::Open setup max out channels = %ld", out_max);

  117.             outchannels = out_max;

  118.         }

  119. 

  120.         //too many channels required, take max available

  121.         if (inchannels > in_max)

  122.         {

  123.             jack_error("This device has only %d available input channels.", in_max);

  124.             inchannels = in_max;

  125.         }

  126.         if (outchannels > out_max)

  127.         {

  128.             jack_error("This device has only %d available output channels.", out_max);

  129.             outchannels = out_max;

  130.         }

  131. 

  132.         //in/out streams parametering

  133.         inputParameters.device = fInputDevice;

  134.         inputParameters.channelCount = inchannels;

  135.         inputParameters.sampleFormat = paFloat32 | paNonInterleaved;		// 32 bit floating point output

  136.         inputParameters.suggestedLatency = (fInputDevice != paNoDevice)		// TODO: check how to setup this on ASIO

  137. 										   ? fPaDevices->GetDeviceInfo(fInputDevice)->defaultLowInputLatency

  138.                                            : 0;

  139.         inputParameters.hostApiSpecificStreamInfo = NULL;

  140. 

  141.         outputParameters.device = fOutputDevice;

  142.         outputParameters.channelCount = outchannels;

  143.         outputParameters.sampleFormat = paFloat32 | paNonInterleaved;		// 32 bit floating point output

  144.         outputParameters.suggestedLatency = (fOutputDevice != paNoDevice)	// TODO: check how to setup this on ASIO

  145.                                             ? fPaDevices->GetDeviceInfo(fOutputDevice)->defaultLowOutputLatency

  146.                                             : 0;

  147.         outputParameters.hostApiSpecificStreamInfo = NULL;

  148. 

  149.         err = Pa_OpenStream(&fStream,

  150.                             (fInputDevice == paNoDevice) ? 0 : &inputParameters,

  151.                             (fOutputDevice == paNoDevice) ? 0 : &outputParameters,

  152.                             samplerate,

  153.                             buffer_size,

  154.                             paNoFlag,  // Clipping is on...

  155.                             Render,

  156.                             this);

  157.         if (err != paNoError)

  158.         {

  159.             jack_error("Pa_OpenStream error = %s\n", Pa_GetErrorText(err));

  160.             goto error;

  161.         }

  162. 

  163. #ifdef __APPLE__

  164.         fEngineControl->fPeriod = fEngineControl->fPeriodUsecs * 1000;

  165.         fEngineControl->fComputation = 500 * 1000;

  166.         fEngineControl->fConstraint = fEngineControl->fPeriodUsecs * 1000;

  167. #endif

  168. 

  169.         // Core driver may have changed the in/out values

  170.         fCaptureChannels = inchannels;

  171.         fPlaybackChannels = outchannels;

  172. 

  173.         assert(strlen(capture_driver_uid) < JACK_CLIENT_NAME_SIZE);

  174.         assert(strlen(playback_driver_uid) < JACK_CLIENT_NAME_SIZE);

  175. 

  176.         strcpy(fCaptureDriverName, capture_driver_uid);

  177.         strcpy(fPlaybackDriverName, playback_driver_uid);

  178. 

  179.         return 0;

  180. 

  181. error:

  182.         jack_error ( "Can't open default PortAudio device : %s", Pa_GetErrorText(err) );

  183.         return -1;

  184.     }

  185. 

  186.     int JackPortAudioDriver::Close()

  187.     {

  188.         JackAudioDriver::Close();

  189.         jack_log("JackPortAudioDriver::Close");

  190.         Pa_CloseStream(fStream);

  191.         return 0;

  192.     }

  193. 

  194.     int JackPortAudioDriver::Start()

  195.     {

  196.         jack_log("JackPortAudioDriver::Start");

  197.         JackAudioDriver::Start();

  198.         PaError err = Pa_StartStream(fStream);

  199.         return (err == paNoError) ? 0 : -1;

  200.     }

  201. 

  202.     int JackPortAudioDriver::Stop()

  203.     {

  204.         jack_log("JackPortAudioDriver::Stop");

  205.         PaError err = Pa_StopStream(fStream);

  206.         return (err == paNoError) ? 0 : -1;

  207.     }

  208. 

  209.     int JackPortAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  210.     {

  211.         PaError err;

  212.         PaStreamParameters inputParameters;

  213.         PaStreamParameters outputParameters;

  214. 

  215.         if ((err = Pa_CloseStream(fStream)) != paNoError)

  216.         {

  217.             jack_error("Pa_CloseStream error = %s\n", Pa_GetErrorText(err));

  218.             return -1;

  219.         }

  220. 

  221.         //change parametering

  222.         inputParameters.device = fInputDevice;

  223.         inputParameters.channelCount = fCaptureChannels;

  224.         inputParameters.sampleFormat = paFloat32 | paNonInterleaved;		// 32 bit floating point output

  225.         inputParameters.suggestedLatency = (fInputDevice != paNoDevice)		// TODO: check how to setup this on ASIO

  226.                                            ? Pa_GetDeviceInfo(inputParameters.device)->defaultLowInputLatency

  227.                                            : 0;

  228.         inputParameters.hostApiSpecificStreamInfo = NULL;

  229. 

  230.         outputParameters.device = fOutputDevice;

  231.         outputParameters.channelCount = fPlaybackChannels;

  232.         outputParameters.sampleFormat = paFloat32 | paNonInterleaved;		// 32 bit floating point output

  233.         outputParameters.suggestedLatency = (fOutputDevice != paNoDevice)	// TODO: check how to setup this on ASIO

  234.                                             ? Pa_GetDeviceInfo(outputParameters.device)->defaultLowOutputLatency

  235.                                             : 0;

  236.         outputParameters.hostApiSpecificStreamInfo = NULL;

  237. 

  238.         err = Pa_OpenStream(&fStream,

  239.                             (fInputDevice == paNoDevice) ? 0 : &inputParameters,

  240.                             (fOutputDevice == paNoDevice) ? 0 : &outputParameters,

  241.                             fEngineControl->fSampleRate,

  242.                             buffer_size,

  243.                             paNoFlag,  // Clipping is on...

  244.                             Render,

  245.                             this);

  246. 

  247.         if (err != paNoError)

  248.         {

  249.             jack_error("Pa_OpenStream error = %s\n", Pa_GetErrorText(err));

  250.             return -1;

  251.         }

  252.         else

  253.         {

  254.             // Only done when success

  255.             return JackAudioDriver::SetBufferSize(buffer_size); // never fails

  256.         }

  257.     }

  258. 

  259. } // end of namespace

  260. 

  261. #ifdef __cplusplus

  262. extern "C"

  263. {

  264. #endif

  265. 

  266. #include "JackCompilerDeps.h"

  267. 

  268.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor()

  269.     {

  270.         jack_driver_desc_t *desc;

  271.         unsigned int i;

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

  273. 

  274.         strcpy(desc->name, "portaudio");                             // size MUST be less then JACK_DRIVER_NAME_MAX + 1

  275.         strcpy(desc->desc, "PortAudio API based audio backend");     // size MUST be less then JACK_DRIVER_PARAM_DESC + 1

  276.           

  277.         desc->nparams = 13;

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

  279. 

  280.         i = 0;

  281.         strcpy(desc->params[i].name, "channels");

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

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

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

  285.         strcpy(desc->params[i].short_desc, "Maximum number of channels");

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

  287. 

  288.         i++;

  289.         strcpy(desc->params[i].name, "inchannels");

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

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

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

  293.         strcpy(desc->params[i].short_desc, "Maximum number of input channels");

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

  295. 

  296.         i++;

  297.         strcpy(desc->params[i].name, "outchannels");

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

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

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

  301.         strcpy(desc->params[i].short_desc, "Maximum number of output channels");

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

  303. 

  304.         i++;

  305.         strcpy(desc->params[i].name, "capture");

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

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

  308.         strcpy(desc->params[i].value.str, "will take default PortAudio input device");

  309.         strcpy(desc->params[i].short_desc, "Provide capture ports. Optionally set PortAudio device name");

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

  311. 

  312.         i++;

  313.         strcpy(desc->params[i].name, "playback");

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

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

  316.         strcpy(desc->params[i].value.str, "will take default PortAudio output device");

  317.         strcpy(desc->params[i].short_desc, "Provide playback ports. Optionally set PortAudio device name");

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

  319. 

  320.         i++;

  321.         strcpy (desc->params[i].name, "monitor");

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

  323.         desc->params[i].type = JackDriverParamBool;

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

  325.         strcpy(desc->params[i].short_desc, "Provide monitor ports for the output");

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

  327. 

  328.         i++;

  329.         strcpy(desc->params[i].name, "duplex");

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

  331.         desc->params[i].type = JackDriverParamBool;

  332.         desc->params[i].value.i = TRUE;

  333.         strcpy(desc->params[i].short_desc, "Provide both capture and playback ports");

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

  335. 

  336.         i++;

  337.         strcpy(desc->params[i].name, "rate");

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

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

  340.         desc->params[i].value.ui = 44100U;

  341.         strcpy(desc->params[i].short_desc, "Sample rate");

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

  343. 

  344.         i++;

  345.         strcpy(desc->params[i].name, "period");

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

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

  348.         desc->params[i].value.ui = 128U;

  349.         strcpy(desc->params[i].short_desc, "Frames per period");

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

  351. 

  352.         i++;

  353.         strcpy(desc->params[i].name, "device");

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

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

  356.         desc->params[i].value.ui = 128U;

  357.         strcpy(desc->params[i].value.str, "will take default PortAudio device name");

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

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

  360. 

  361.         i++;

  362.         strcpy(desc->params[i].name, "input-latency");

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

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

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

  366.         strcpy(desc->params[i].short_desc, "Extra input latency");

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

  368. 

  369.         i++;

  370.         strcpy(desc->params[i].name, "output-latency");

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

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

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

  374.         strcpy(desc->params[i].short_desc, "Extra output latency");

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

  376. 

  377.         i++;

  378.         strcpy(desc->params[i].name, "list-devices");

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

  380.         desc->params[i].type = JackDriverParamBool;

  381.         desc->params[i].value.i = TRUE;

  382.         strcpy(desc->params[i].short_desc, "Display available PortAudio devices");

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

  384. 

  385.         return desc;

  386.     }

  387. 

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

  389.     {

  390.         jack_nframes_t srate = 44100;

  391.         jack_nframes_t frames_per_interrupt = 512;

  392.         const char* capture_pcm_name = "";

  393.         const char* playback_pcm_name = "";

  394.         int capture = FALSE;

  395.         int playback = FALSE;

  396.         int chan_in = 0;

  397.         int chan_out = 0;

  398.         bool monitor = false;

  399.         const JSList *node;

  400.         const jack_driver_param_t *param;

  401.         jack_nframes_t systemic_input_latency = 0;

  402.         jack_nframes_t systemic_output_latency = 0;

  403.         PortAudioDevices* pa_devices = new PortAudioDevices();

  404. 

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

  406.         {

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

  408. 

  409.             switch (param->character)

  410.             {

  411. 

  412.             case 'd':

  413.                 capture_pcm_name = strdup(param->value.str);

  414.                 playback_pcm_name = strdup(param->value.str);

  415.                 break;

  416. 

  417.             case 'D':

  418.                 capture = TRUE;

  419.                 playback = TRUE;

  420.                 break;

  421. 

  422.             case 'c':

  423.                 chan_in = chan_out = (int) param->value.ui;

  424.                 break;

  425. 

  426.             case 'i':

  427.                 chan_in = (int) param->value.ui;

  428.                 break;

  429. 

  430.             case 'o':

  431.                 chan_out = (int) param->value.ui;

  432.                 break;

  433. 

  434.             case 'C':

  435.                 capture = TRUE;

  436.                 if (strcmp(param->value.str, "none") != 0)

  437.                 {

  438.                     capture_pcm_name = strdup(param->value.str);

  439.                 }

  440.                 break;

  441. 

  442.             case 'P':

  443.                 playback = TRUE;

  444.                 if (strcmp(param->value.str, "none") != 0)

  445.                 {

  446.                     playback_pcm_name = strdup(param->value.str);

  447.                 }

  448.                 break;

  449. 

  450.             case 'm':

  451.                 monitor = param->value.i;

  452.                 break;

  453. 

  454.             case 'r':

  455.                 srate = param->value.ui;

  456.                 break;

  457. 

  458.             case 'p':

  459.                 frames_per_interrupt = (unsigned int) param->value.ui;

  460.                 break;

  461. 

  462.             case 'I':

  463.                 systemic_input_latency = param->value.ui;

  464.                 break;

  465. 

  466.             case 'O':

  467.                 systemic_output_latency = param->value.ui;

  468.                 break;

  469. 

  470.             case 'l':

  471.                 pa_devices->DisplayDevicesNames();

  472.                 break;

  473.             }

  474.         }

  475. 

  476.         // duplex is the default

  477.         if (!capture && !playback)

  478.         {

  479.             capture = TRUE;

  480.             playback = TRUE;

  481.         }

  482. 

  483.         Jack::JackDriverClientInterface* driver = new Jack::JackPortAudioDriver("system", "portaudio", engine, table, pa_devices);

  484.         if (driver->Open(frames_per_interrupt, srate, capture, playback, chan_in, chan_out, monitor, capture_pcm_name, playback_pcm_name, systemic_input_latency, systemic_output_latency) == 0)

  485.         {

  486.             return driver;

  487.         }

  488.         else

  489.         {

  490.             delete driver;

  491.             return NULL;

  492.         }

  493.     }

  494. 

  495. #ifdef __cplusplus

  496. }

  497. #endif