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

504 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 "JackExports.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.         {

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

  62.         }

  63.         return 0;

  64.     }

  65. 

  66.     int JackPortAudioDriver::Write()

  67.     {

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

  69.         {

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

  71.         }

  72.         return 0;

  73.     }

  74. 

  75.     int JackPortAudioDriver::Open(jack_nframes_t nframes,

  76.                                   jack_nframes_t samplerate,

  77.                                   bool capturing,

  78.                                   bool playing,

  79.                                   int inchannels,

  80.                                   int outchannels,

  81.                                   bool monitor,

  82.                                   const char* capture_driver_uid,

  83.                                   const char* playback_driver_uid,

  84.                                   jack_nframes_t capture_latency,

  85.                                   jack_nframes_t playback_latency)

  86.     {

  87.         PaError err;

  88.         PaStreamParameters inputParameters;

  89.         PaStreamParameters outputParameters;

  90.         int in_max = 0;

  91.         int out_max = 0;

  92. 

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

  94.                  nframes, inchannels, outchannels, capture_driver_uid, playback_driver_uid, samplerate);

  95. 

  96.         // Generic JackAudioDriver Open

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

  98.         {

  99.             return -1;

  100.         }

  101. 

  102.         //get devices

  103.         if (capturing)

  104.         {

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

  106.                 goto error;

  107.         }

  108.         if (playing)

  109.         {

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

  111.                 goto error;

  112.         }

  113. 

  114.         //default channels number required

  115.         if (inchannels == 0)

  116.         {

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

  118.             inchannels = in_max;

  119.         }

  120.         if (outchannels == 0)

  121.         {

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

  123.             outchannels = out_max;

  124.         }

  125. 

  126.         //doesn't have enough in/out channels...exit

  127.         if (inchannels > in_max)

  128.         {

  129.             jack_error("This device hasn't required input channels inchannels = %ld in_max = %ld", inchannels, in_max);

  130.             goto error;

  131.         }

  132.         if (outchannels > out_max)

  133.         {

  134.             jack_error("This device hasn't required output channels outchannels = %ld out_max = %ld", outchannels, out_max);

  135.             goto error;

  136.         }

  137. 

  138.         //in/output streams parametering

  139.         inputParameters.device = fInputDevice;

  140.         inputParameters.channelCount = inchannels;

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

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

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

  144.                                            : 0;

  145.         inputParameters.hostApiSpecificStreamInfo = NULL;

  146. 

  147.         outputParameters.device = fOutputDevice;

  148.         outputParameters.channelCount = outchannels;

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

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

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

  152.                                             : 0;

  153.         outputParameters.hostApiSpecificStreamInfo = NULL;

  154. 

  155.         err = Pa_OpenStream(&fStream,

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

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

  158.                             samplerate,

  159.                             nframes,

  160.                             paNoFlag,  // Clipping is on...

  161.                             Render,

  162.                             this);

  163.         if (err != paNoError)

  164.         {

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

  166.             goto error;

  167.         }

  168. 

  169. #ifdef __APPLE__

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

  171.         fEngineControl->fComputation = 500 * 1000;

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

  173. #endif

  174. 

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

  176.         fCaptureChannels = inchannels;

  177.         fPlaybackChannels = outchannels;

  178. 

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

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

  181. 

  182.         strcpy(fCaptureDriverName, capture_driver_uid);

  183.         strcpy(fPlaybackDriverName, playback_driver_uid);

  184. 

  185.         return 0;

  186. 

  187. error:

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

  189.         return -1;

  190.     }

  191. 

  192.     int JackPortAudioDriver::Close()

  193.     {

  194.         JackAudioDriver::Close();

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

  196.         Pa_CloseStream(fStream);

  197.         delete fPaDevices;

  198.         return 0;

  199.     }

  200. 

  201.     int JackPortAudioDriver::Start()

  202.     {

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

  204.         JackAudioDriver::Start();

  205.         PaError err = Pa_StartStream(fStream);

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

  207.     }

  208. 

  209.     int JackPortAudioDriver::Stop()

  210.     {

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

  212.         PaError err = Pa_StopStream(fStream);

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

  214.     }

  215. 

  216.     int JackPortAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  217.     {

  218.         PaError err;

  219.         PaStreamParameters inputParameters;

  220.         PaStreamParameters outputParameters;

  221. 

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

  223.         {

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

  225.             return -1;

  226.         }

  227. 

  228.         //change parametering

  229.         inputParameters.device = fInputDevice;

  230.         inputParameters.channelCount = fCaptureChannels;

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

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

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

  234.                                            : 0;

  235.         inputParameters.hostApiSpecificStreamInfo = NULL;

  236. 

  237.         outputParameters.device = fOutputDevice;

  238.         outputParameters.channelCount = fPlaybackChannels;

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

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

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

  242.                                             : 0;

  243.         outputParameters.hostApiSpecificStreamInfo = NULL;

  244. 

  245.         err = Pa_OpenStream(&fStream,

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

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

  248.                             fEngineControl->fSampleRate,

  249.                             buffer_size,

  250.                             paNoFlag,  // Clipping is on...

  251.                             Render,

  252.                             this);

  253. 

  254.         if (err != paNoError)

  255.         {

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

  257.             return -1;

  258.         }

  259.         else

  260.         {

  261.             // Only done when success

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

  263.         }

  264.     }

  265. 

  266. } // end of namespace

  267. 

  268. #ifdef __cplusplus

  269. extern "C"

  270. {

  271. #endif

  272. 

  273. #include "JackExports.h"

  274. 

  275.     EXPORT jack_driver_desc_t* driver_get_descriptor()

  276.     {

  277.         jack_driver_desc_t *desc;

  278.         unsigned int i;

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

  280. 

  281.         strcpy(desc->name, "portaudio");

  282. 

  283.         desc->nparams = 13;

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

  285. 

  286.         i = 0;

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

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

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

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

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

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

  293. 

  294.         i++;

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

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

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

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

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

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

  301. 

  302.         i++;

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

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

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

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

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

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

  309. 

  310.         i++;

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

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

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

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

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

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

  317. 

  318.         i++;

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

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

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

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

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

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

  325. 

  326.         i++;

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

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

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

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

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

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

  333. 

  334.         i++;

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

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

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

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

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

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

  341. 

  342.         i++;

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

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

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

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

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

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

  349. 

  350.         i++;

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

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

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

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

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

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

  357. 

  358.         i++;

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

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

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

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

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

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

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

  366. 

  367.         i++;

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

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

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

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

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

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

  374. 

  375.         i++;

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

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

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

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

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

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

  382. 

  383.         i++;

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

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

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

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

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

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

  390. 

  391.         return desc;

  392.     }

  393. 

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

  395.     {

  396.         jack_nframes_t srate = 44100;

  397.         jack_nframes_t frames_per_interrupt = 512;

  398.         const char* capture_pcm_name = "";

  399.         const char* playback_pcm_name = "";

  400.         int capture = FALSE;

  401.         int playback = FALSE;

  402.         int chan_in = 0;

  403.         int chan_out = 0;

  404.         bool monitor = false;

  405.         const JSList *node;

  406.         const jack_driver_param_t *param;

  407.         jack_nframes_t systemic_input_latency = 0;

  408.         jack_nframes_t systemic_output_latency = 0;

  409.         PortAudioDevices* pa_devices = new PortAudioDevices();

  410. 

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

  412.         {

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

  414. 

  415.             switch (param->character)

  416.             {

  417. 

  418.             case 'd':

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

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

  421.                 break;

  422. 

  423.             case 'D':

  424.                 capture = TRUE;

  425.                 playback = TRUE;

  426.                 break;

  427. 

  428.             case 'c':

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

  430.                 break;

  431. 

  432.             case 'i':

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

  434.                 break;

  435. 

  436.             case 'o':

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

  438.                 break;

  439. 

  440.             case 'C':

  441.                 capture = TRUE;

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

  443.                 {

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

  445.                 }

  446.                 break;

  447. 

  448.             case 'P':

  449.                 playback = TRUE;

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

  451.                 {

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

  453.                 }

  454.                 break;

  455. 

  456.             case 'm':

  457.                 monitor = param->value.i;

  458.                 break;

  459. 

  460.             case 'r':

  461.                 srate = param->value.ui;

  462.                 break;

  463. 

  464.             case 'p':

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

  466.                 break;

  467. 

  468.             case 'I':

  469.                 systemic_input_latency = param->value.ui;

  470.                 break;

  471. 

  472.             case 'O':

  473.                 systemic_output_latency = param->value.ui;

  474.                 break;

  475. 

  476.             case 'l':

  477.                 pa_devices->DisplayDevicesNames();

  478.                 break;

  479.             }

  480.         }

  481. 

  482.         // duplex is the default

  483.         if (!capture && !playback)

  484.         {

  485.             capture = TRUE;

  486.             playback = TRUE;

  487.         }

  488. 

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

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

  491.         {

  492.             return driver;

  493.         }

  494.         else

  495.         {

  496.             delete driver;

  497.             return NULL;

  498.         }

  499.     }

  500. 

  501. #ifdef __cplusplus

  502. }

  503. #endif