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

493 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. #include "JackDriverLoader.h"

  21. #include "driver_interface.h"

  22. #include "JackPortAudioDriver.h"

  23. #include "JackEngineControl.h"

  24. #include "JackError.h"

  25. #include "JackTime.h"

  26. #include "JackCompilerDeps.h"

  27. #include <iostream>

  28. #include <assert.h>

  29. 

  30. using namespace std;

  31. 

  32. namespace Jack

  33. {

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

  35.                                     unsigned long framesPerBuffer,

  36.                                     const PaStreamCallbackTimeInfo* timeInfo,

  37.                                     PaStreamCallbackFlags statusFlags,

  38.                                     void* userData)

  39.     {

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

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

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

  43.         // Setup threadded based log function

  44.         set_threaded_log_function();

  45.         driver->CycleTakeBeginTime();

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

  47.     }

  48. 

  49.     int JackPortAudioDriver::Read()

  50.     {

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

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

  53.         return 0;

  54.     }

  55. 

  56.     int JackPortAudioDriver::Write()

  57.     {

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

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

  60.         return 0;

  61.     }

  62. 

  63.     int JackPortAudioDriver::Open(jack_nframes_t buffer_size,

  64.                                   jack_nframes_t samplerate,

  65.                                   bool capturing,

  66.                                   bool playing,

  67.                                   int inchannels,

  68.                                   int outchannels,

  69.                                   bool monitor,

  70.                                   const char* capture_driver_uid,

  71.                                   const char* playback_driver_uid,

  72.                                   jack_nframes_t capture_latency,

  73.                                   jack_nframes_t playback_latency)

  74.     {

  75.         PaError err = paNoError;

  76.         PaStreamParameters inputParameters;

  77.         PaStreamParameters outputParameters;

  78.         int in_max = 0;

  79.         int out_max = 0;

  80. 

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

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

  83. 

  84.         // Generic JackAudioDriver Open

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

  86.             return -1;

  87. 

  88.         //get devices

  89.         if (capturing)

  90.         {

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

  92.                 goto error;

  93.         }

  94.         if (playing)

  95.         {

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

  97.                 goto error;

  98.         }

  99. 

  100.         jack_log("JackPortAudioDriver::Open fInputDevice = %d, fOutputDevice %d", fInputDevice, fOutputDevice);

  101. 

  102.         //default channels number required

  103.         if (inchannels == 0)

  104.         {

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

  106.             inchannels = in_max;

  107.         }

  108.         if (outchannels == 0)

  109.         {

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

  111.             outchannels = out_max;

  112.         }

  113. 

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

  115.         if (inchannels > in_max)

  116.         {

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

  118.             inchannels = in_max;

  119.         }

  120.         if (outchannels > out_max)

  121.         {

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

  123.             outchannels = out_max;

  124.         }

  125. 

  126.         //in/out streams parametering

  127.         inputParameters.device = fInputDevice;

  128.         inputParameters.channelCount = inchannels;

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

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

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

  132.                                            : 0;

  133.         inputParameters.hostApiSpecificStreamInfo = NULL;

  134. 

  135.         outputParameters.device = fOutputDevice;

  136.         outputParameters.channelCount = outchannels;

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

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

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

  140.                                             : 0;

  141.         outputParameters.hostApiSpecificStreamInfo = NULL;

  142. 

  143.         err = Pa_OpenStream(&fStream,

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

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

  146.                             samplerate,

  147.                             buffer_size,

  148.                             paNoFlag,  // Clipping is on...

  149.                             Render,

  150.                             this);

  151.         if (err != paNoError)

  152.         {

  153.             jack_error("Pa_OpenStream error = %s", Pa_GetErrorText(err));

  154.             goto error;

  155.         }

  156. 

  157. #ifdef __APPLE__

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

  159.         fEngineControl->fComputation = 500 * 1000;

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

  161. #endif

  162. 

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

  164.         fCaptureChannels = inchannels;

  165.         fPlaybackChannels = outchannels;

  166. 

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

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

  169. 

  170.         strcpy(fCaptureDriverName, capture_driver_uid);

  171.         strcpy(fPlaybackDriverName, playback_driver_uid);

  172. 

  173.         return 0;

  174. 

  175. error:

  176.         JackAudioDriver::Close();

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

  178.         return -1;

  179.     }

  180. 

  181.     int JackPortAudioDriver::Close()

  182.     {

  183.         JackAudioDriver::Close();

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

  185.         Pa_CloseStream(fStream);

  186.         return 0;

  187.     }

  188. 

  189.     int JackPortAudioDriver::Start()

  190.     {

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

  192.         JackAudioDriver::Start();

  193.         PaError err = Pa_StartStream(fStream);

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

  195.     }

  196. 

  197.     int JackPortAudioDriver::Stop()

  198.     {

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

  200.         PaError err = Pa_StopStream(fStream);

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

  202.     }

  203. 

  204.     int JackPortAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  205.     {

  206.         PaError err;

  207.         PaStreamParameters inputParameters;

  208.         PaStreamParameters outputParameters;

  209. 

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

  211.         {

  212.             jack_error("Pa_CloseStream error = %s", Pa_GetErrorText(err));

  213.             return -1;

  214.         }

  215. 

  216.         //change parametering

  217.         inputParameters.device = fInputDevice;

  218.         inputParameters.channelCount = fCaptureChannels;

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

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

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

  222.                                            : 0;

  223.         inputParameters.hostApiSpecificStreamInfo = NULL;

  224. 

  225.         outputParameters.device = fOutputDevice;

  226.         outputParameters.channelCount = fPlaybackChannels;

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

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

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

  230.                                             : 0;

  231.         outputParameters.hostApiSpecificStreamInfo = NULL;

  232. 

  233.         err = Pa_OpenStream(&fStream,

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

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

  236.                             fEngineControl->fSampleRate,

  237.                             buffer_size,

  238.                             paNoFlag,  // Clipping is on...

  239.                             Render,

  240.                             this);

  241. 

  242.         if (err != paNoError)

  243.         {

  244.             jack_error("Pa_OpenStream error = %s", Pa_GetErrorText(err));

  245.             return -1;

  246.         }

  247.         else

  248.         {

  249.             // Only done when success

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

  251.         }

  252.     }

  253. 

  254. } // end of namespace

  255. 

  256. #ifdef __cplusplus

  257. extern "C"

  258. {

  259. #endif

  260. 

  261. #include "JackCompilerDeps.h"

  262. 

  263.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor()

  264.     {

  265.         jack_driver_desc_t *desc;

  266.         unsigned int i;

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

  268. 

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

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

  271. 

  272.         desc->nparams = 13;

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

  274. 

  275.         i = 0;

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

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

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

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

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

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

  282. 

  283.         i++;

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

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

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

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

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

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

  290. 

  291.         i++;

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

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

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

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

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

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

  298. 

  299.         i++;

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

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

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

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

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

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

  306. 

  307.         i++;

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

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

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

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

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

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

  314. 

  315.         i++;

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

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

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

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

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

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

  322. 

  323.         i++;

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

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

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

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

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

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

  330. 

  331.         i++;

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

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

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

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

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

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

  338. 

  339.         i++;

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

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

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

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

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

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

  346. 

  347.         i++;

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

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

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

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

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

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

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

  355. 

  356.         i++;

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

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

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

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

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

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

  363. 

  364.         i++;

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

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

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

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

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

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

  371. 

  372.         i++;

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

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

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

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

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

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

  379. 

  380.         return desc;

  381.     }

  382. 

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

  384.     {

  385.         jack_nframes_t srate = 44100;

  386.         jack_nframes_t frames_per_interrupt = 512;

  387.         const char* capture_pcm_name = "";

  388.         const char* playback_pcm_name = "";

  389.         int capture = FALSE;

  390.         int playback = FALSE;

  391.         int chan_in = 0;

  392.         int chan_out = 0;

  393.         bool monitor = false;

  394.         const JSList *node;

  395.         const jack_driver_param_t *param;

  396.         jack_nframes_t systemic_input_latency = 0;

  397.         jack_nframes_t systemic_output_latency = 0;

  398.         PortAudioDevices* pa_devices = new PortAudioDevices();

  399. 

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

  401.         {

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

  403. 

  404.             switch (param->character)

  405.             {

  406. 

  407.             case 'd':

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

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

  410.                 break;

  411. 

  412.             case 'D':

  413.                 capture = TRUE;

  414.                 playback = TRUE;

  415.                 break;

  416. 

  417.             case 'c':

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

  419.                 break;

  420. 

  421.             case 'i':

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

  423.                 break;

  424. 

  425.             case 'o':

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

  427.                 break;

  428. 

  429.             case 'C':

  430.                 capture = TRUE;

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

  432.                 {

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

  434.                 }

  435.                 break;

  436. 

  437.             case 'P':

  438.                 playback = TRUE;

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

  440.                 {

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

  442.                 }

  443.                 break;

  444. 

  445.             case 'm':

  446.                 monitor = param->value.i;

  447.                 break;

  448. 

  449.             case 'r':

  450.                 srate = param->value.ui;

  451.                 break;

  452. 

  453.             case 'p':

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

  455.                 break;

  456. 

  457.             case 'I':

  458.                 systemic_input_latency = param->value.ui;

  459.                 break;

  460. 

  461.             case 'O':

  462.                 systemic_output_latency = param->value.ui;

  463.                 break;

  464. 

  465.             case 'l':

  466.                 pa_devices->DisplayDevicesNames();

  467.                 break;

  468.             }

  469.         }

  470. 

  471.         // duplex is the default

  472.         if (!capture && !playback)

  473.         {

  474.             capture = TRUE;

  475.             playback = TRUE;

  476.         }

  477. 

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

  479.         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)

  480.         {

  481.             return driver;

  482.         }

  483.         else

  484.         {

  485.             delete driver;

  486.             return NULL;

  487.         }

  488.     }

  489. 

  490. #ifdef __cplusplus

  491. }

  492. #endif