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

673 lines
25KB
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. #ifdef WIN32

  21. #pragma warning (disable : 4786)

  22. #endif

  23. 

  24. #include "pa_asio.h"

  25. #include "JackDriverLoader.h"

  26. #include "driver_interface.h"

  27. #include "JackPortAudioDriver.h"

  28. #include "JackEngineControl.h"

  29. #include "JackError.h"

  30. #include "JackTime.h"

  31. #include <iostream>

  32. #include <assert.h>

  33. 

  34. namespace Jack

  35. {

  36. 

  37. void JackPortAudioDriver::PrintSupportedStandardSampleRates(const PaStreamParameters* inputParameters, const PaStreamParameters* outputParameters)

  38. {

  39.     static double standardSampleRates[] = {

  40.                                               8000.0, 9600.0, 11025.0, 12000.0, 16000.0, 22050.0, 24000.0, 32000.0,

  41.                                               44100.0, 48000.0, 88200.0, 96000.0, 192000.0, -1 /* negative terminated  list */

  42.                                           };

  43.     int i, printCount;

  44.     PaError err;

  45. 

  46.     printCount = 0;

  47.     for (i = 0; standardSampleRates[i] > 0; i++) {

  48.         err = Pa_IsFormatSupported(inputParameters, outputParameters, standardSampleRates[i]);

  49.         if (err == paFormatIsSupported) {

  50.             if (printCount == 0) {

  51.                 printf("\t%8.2f", standardSampleRates[i]);

  52.                 printCount = 1;

  53.             } else if (printCount == 4) {

  54.                 printf(",\n\t%8.2f", standardSampleRates[i]);

  55.                 printCount = 1;

  56.             } else {

  57.                 printf(", %8.2f", standardSampleRates[i]);

  58.                 ++printCount;

  59.             }

  60.         }

  61.     }

  62.     if (!printCount)

  63.         printf("None\n");

  64.     else

  65.         printf("\n");

  66. }

  67. 

  68. bool JackPortAudioDriver::GetInputDeviceFromName(const char* name, PaDeviceIndex* device, int* in_max)

  69. {

  70.     const PaDeviceInfo* deviceInfo;

  71.     PaDeviceIndex numDevices = Pa_GetDeviceCount();

  72. 

  73.     for (int i = 0; i < numDevices; i++) {

  74.         deviceInfo = Pa_GetDeviceInfo(i);

  75.         if (strcmp(name, deviceInfo->name) == 0) {

  76.             *device = i;

  77.             *in_max = deviceInfo->maxInputChannels;

  78.             return true;

  79.         }

  80.     }

  81. 

  82.     return false;

  83. }

  84. 

  85. bool JackPortAudioDriver::GetOutputDeviceFromName(const char* name, PaDeviceIndex* device, int* out_max)

  86. {

  87.     const PaDeviceInfo* deviceInfo;

  88.     PaDeviceIndex numDevices = Pa_GetDeviceCount();

  89. 

  90.     for (int i = 0; i < numDevices; i++) {

  91.         deviceInfo = Pa_GetDeviceInfo(i);

  92.         if (strcmp(name, deviceInfo->name) == 0) {

  93.             *device = i;

  94.             *out_max = deviceInfo->maxOutputChannels;

  95.             return true;

  96.         }

  97.     }

  98. 

  99.     return false;

  100. }

  101. 

  102. static void DisplayDeviceNames()

  103. {

  104.     PaError err;

  105.     const PaDeviceInfo* deviceInfo;

  106.     PaStreamParameters inputParameters, outputParameters;

  107.     int defaultDisplayed;

  108. 

  109.     err = Pa_Initialize();

  110.     if (err != paNoError)

  111.         return ;

  112. 

  113.     PaDeviceIndex numDevices = Pa_GetDeviceCount();

  114.     printf("Number of devices = %d\n", numDevices);

  115. 

  116.     for (int i = 0; i < numDevices; i++) {

  117.         deviceInfo = Pa_GetDeviceInfo(i);

  118.         printf( "--------------------------------------- device #%d\n", i );

  119. 

  120.         /* Mark global and API specific default devices */

  121.         defaultDisplayed = 0;

  122.         if (i == Pa_GetDefaultInputDevice()) {

  123.             printf("[ Default Input");

  124.             defaultDisplayed = 1;

  125.         } else if (i == Pa_GetHostApiInfo(deviceInfo->hostApi)->defaultInputDevice) {

  126.             const PaHostApiInfo *hostInfo = Pa_GetHostApiInfo(deviceInfo->hostApi);

  127.             printf("[ Default %s Input", hostInfo->name);

  128.             defaultDisplayed = 1;

  129.         }

  130. 

  131.         if (i == Pa_GetDefaultOutputDevice()) {

  132.             printf((defaultDisplayed ? "," : "["));

  133.             printf(" Default Output");

  134.             defaultDisplayed = 1;

  135.         } else if (i == Pa_GetHostApiInfo(deviceInfo->hostApi)->defaultOutputDevice) {

  136.             const PaHostApiInfo *hostInfo = Pa_GetHostApiInfo(deviceInfo->hostApi);

  137.             printf((defaultDisplayed ? "," : "["));

  138.             printf(" Default %s Output", hostInfo->name);

  139.             defaultDisplayed = 1;

  140.         }

  141. 

  142.         if (defaultDisplayed)

  143.             printf(" ]\n");

  144. 

  145.         /* print device info fields */

  146.         printf("Name                        = %s\n", deviceInfo->name);

  147.         printf("Host API                    = %s\n", Pa_GetHostApiInfo(deviceInfo->hostApi)->name);

  148.         printf("Max inputs = %d", deviceInfo->maxInputChannels);

  149.         printf(", Max outputs = %d\n", deviceInfo->maxOutputChannels);

  150.         /*

  151.               printf("Default low input latency   = %8.3f\n", deviceInfo->defaultLowInputLatency);

  152.               printf("Default low output latency  = %8.3f\n", deviceInfo->defaultLowOutputLatency);

  153.               printf("Default high input latency  = %8.3f\n", deviceInfo->defaultHighInputLatency);

  154.               printf("Default high output latency = %8.3f\n", deviceInfo->defaultHighOutputLatency);

  155.         */

  156. 

  157. #ifdef WIN32

  158. #ifndef PA_NO_ASIO

  159.         /* ASIO specific latency information */

  160.         if (Pa_GetHostApiInfo(deviceInfo->hostApi)->type == paASIO) {

  161.             long minLatency, maxLatency, preferredLatency, granularity;

  162. 

  163.             err = PaAsio_GetAvailableLatencyValues(i, &minLatency, &maxLatency, &preferredLatency, &granularity);

  164. 

  165.             printf("ASIO minimum buffer size    = %ld\n", minLatency);

  166.             printf("ASIO maximum buffer size    = %ld\n", maxLatency);

  167.             printf("ASIO preferred buffer size  = %ld\n", preferredLatency);

  168. 

  169.             if (granularity == -1)

  170.                 printf("ASIO buffer granularity     = power of 2\n");

  171.             else

  172.                 printf("ASIO buffer granularity     = %ld\n", granularity);

  173.         }

  174. #endif /* !PA_NO_ASIO */

  175. #endif /* WIN32 */

  176. 

  177.         printf("Default sample rate         = %8.2f\n", deviceInfo->defaultSampleRate);

  178. 

  179.         /* poll for standard sample rates */

  180.         inputParameters.device = i;

  181.         inputParameters.channelCount = deviceInfo->maxInputChannels;

  182.         inputParameters.sampleFormat = paInt16;

  183.         inputParameters.suggestedLatency = 0; /* ignored by Pa_IsFormatSupported() */

  184.         inputParameters.hostApiSpecificStreamInfo = NULL;

  185. 

  186.         outputParameters.device = i;

  187.         outputParameters.channelCount = deviceInfo->maxOutputChannels;

  188.         outputParameters.sampleFormat = paInt16;

  189.         outputParameters.suggestedLatency = 0; /* ignored by Pa_IsFormatSupported() */

  190.         outputParameters.hostApiSpecificStreamInfo = NULL;

  191. 

  192.         /*

  193.               if (inputParameters.channelCount > 0) {

  194.                   printf("Supported standard sample rates\n for half-duplex 16 bit %d channel input = \n", inputParameters.channelCount);

  195.                   PrintSupportedStandardSampleRates(&inputParameters, NULL);

  196.               }

  197. 

  198.               if (outputParameters.channelCount > 0) {

  199.                   printf("Supported standard sample rates\n for half-duplex 16 bit %d channel output = \n", outputParameters.channelCount);

  200.                   PrintSupportedStandardSampleRates(NULL, &outputParameters);

  201.               }

  202. 

  203.               if (inputParameters.channelCount > 0 && outputParameters.channelCount > 0) {

  204.                   printf("Supported standard sample rates\n for full-duplex 16 bit %d channel input, %d channel output = \n",

  205.                           inputParameters.channelCount, outputParameters.channelCount );

  206.                   PrintSupportedStandardSampleRates(&inputParameters, &outputParameters);

  207.               }

  208.         */

  209.     }

  210. 

  211.     Pa_Terminate();

  212. }

  213. 

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

  215.                                 unsigned long framesPerBuffer,

  216.                                 const PaStreamCallbackTimeInfo* timeInfo,

  217.                                 PaStreamCallbackFlags statusFlags,

  218.                                 void* userData)

  219. {

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

  221.     driver->fLastWaitUst = GetMicroSeconds(); // Take callback date here

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

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

  224.     // Setup threadded based log function

  225.     set_threaded_log_function();

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

  227. }

  228. 

  229. int JackPortAudioDriver::Read()

  230. {

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

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

  233.     }

  234.     return 0;

  235. }

  236. 

  237. int JackPortAudioDriver::Write()

  238. {

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

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

  241.     }

  242.     return 0;

  243. }

  244. 

  245. int JackPortAudioDriver::Open(jack_nframes_t nframes,

  246.                               jack_nframes_t samplerate,

  247.                               bool capturing,

  248.                               bool playing,

  249.                               int inchannels,

  250.                               int outchannels,

  251.                               bool monitor,

  252.                               const char* capture_driver_uid,

  253.                               const char* playback_driver_uid,

  254.                               jack_nframes_t capture_latency,

  255.                               jack_nframes_t playback_latency)

  256. {

  257.     PaError err;

  258.     PaStreamParameters inputParameters;

  259.     PaStreamParameters outputParameters;

  260.     const PaDeviceInfo* deviceInfo;

  261.     int in_max = 0;

  262.     int out_max = 0;

  263. 

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

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

  266. 

  267.     // Generic JackAudioDriver Open

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

  269.         return -1;

  270.     }

  271. 

  272.     err = Pa_Initialize();

  273.     if (err != paNoError) {

  274.         jack_error("JackPortAudioDriver::Pa_Initialize error = %s\n", Pa_GetErrorText(err));

  275.         goto error;

  276.     }

  277. 

  278.     jack_log("JackPortAudioDriver::Pa_GetDefaultInputDevice %ld", Pa_GetDefaultInputDevice());

  279.     jack_log("JackPortAudioDriver::Pa_GetDefaultOutputDevice %ld", Pa_GetDefaultOutputDevice());

  280. 

  281.     if (capturing) {

  282.         if (!GetInputDeviceFromName(capture_driver_uid, &fInputDevice, &in_max)) {

  283.             jack_log("JackPortAudioDriver::GetInputDeviceFromName cannot open %s", capture_driver_uid);

  284.             fInputDevice = Pa_GetDefaultInputDevice();

  285.             if (fInputDevice == paNoDevice)

  286.                 goto error;

  287.             deviceInfo = Pa_GetDeviceInfo(fInputDevice);

  288.             in_max = deviceInfo->maxInputChannels;

  289.             capture_driver_uid = strdup(deviceInfo->name);

  290.         }

  291.     }

  292. 

  293.     if (inchannels > in_max) {

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

  295.         goto error;

  296.     }

  297. 

  298.     if (playing) {

  299.         if (!GetOutputDeviceFromName(playback_driver_uid, &fOutputDevice, &out_max)) {

  300.             jack_log("JackPortAudioDriver::GetOutputDeviceFromName cannot open %s", playback_driver_uid);

  301.             fOutputDevice = Pa_GetDefaultOutputDevice();

  302.             if (fOutputDevice == paNoDevice)

  303.                 goto error;

  304.             deviceInfo = Pa_GetDeviceInfo(fOutputDevice);

  305.             out_max = deviceInfo->maxOutputChannels;

  306.             playback_driver_uid = strdup(deviceInfo->name);

  307.         }

  308.     }

  309. 

  310.     if (outchannels > out_max) {

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

  312.         goto error;

  313.     }

  314. 

  315.     if (inchannels == 0) {

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

  317.         inchannels = in_max;

  318.     }

  319. 

  320.     if (outchannels == 0) {

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

  322.         outchannels = out_max;

  323.     }

  324. 

  325.     inputParameters.device = fInputDevice;

  326.     inputParameters.channelCount = inchannels;

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

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

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

  330.                                        : 0;

  331.     inputParameters.hostApiSpecificStreamInfo = NULL;

  332. 

  333.     outputParameters.device = fOutputDevice;

  334.     outputParameters.channelCount = outchannels;

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

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

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

  338.                                         : 0;

  339.     outputParameters.hostApiSpecificStreamInfo = NULL;

  340. 

  341.     err = Pa_OpenStream(&fStream,

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

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

  344.                         samplerate,

  345.                         nframes,

  346.                         paNoFlag,  // Clipping is on...

  347.                         Render,

  348.                         this);

  349.     if (err != paNoError) {

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

  351.         goto error;

  352.     }

  353. 

  354. #ifdef __APPLE__

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

  356.     fEngineControl->fComputation = 500 * 1000;

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

  358. #endif

  359. 

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

  361.     fCaptureChannels = inchannels;

  362.     fPlaybackChannels = outchannels;

  363. 

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

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

  366. 

  367.     strcpy(fCaptureDriverName, capture_driver_uid);

  368.     strcpy(fPlaybackDriverName, playback_driver_uid);

  369. 

  370.     return 0;

  371. 

  372. error:

  373.     Pa_Terminate();

  374.     return -1;

  375. }

  376. 

  377. int JackPortAudioDriver::Close()

  378. {

  379.     JackAudioDriver::Close();

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

  381.     Pa_CloseStream(fStream);

  382.     Pa_Terminate();

  383.     return 0;

  384. }

  385. 

  386. int JackPortAudioDriver::Start()

  387. {

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

  389.     JackAudioDriver::Start();

  390.     PaError err = Pa_StartStream(fStream);

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

  392. }

  393. 

  394. int JackPortAudioDriver::Stop()

  395. {

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

  397.     PaError err = Pa_StopStream(fStream);

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

  399. }

  400. 

  401. int JackPortAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  402. {

  403.     PaError err;

  404.     PaStreamParameters inputParameters;

  405.     PaStreamParameters outputParameters;

  406. 

  407.     if ((err = Pa_CloseStream(fStream)) != paNoError) {

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

  409.         return -1;

  410.     }

  411. 

  412.     inputParameters.device = fInputDevice;

  413.     inputParameters.channelCount = fCaptureChannels;

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

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

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

  417.                                        : 0;

  418.     inputParameters.hostApiSpecificStreamInfo = NULL;

  419. 

  420.     outputParameters.device = fOutputDevice;

  421.     outputParameters.channelCount = fPlaybackChannels;

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

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

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

  425.                                         : 0;

  426.     outputParameters.hostApiSpecificStreamInfo = NULL;

  427. 

  428.     err = Pa_OpenStream(&fStream,

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

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

  431.                         fEngineControl->fSampleRate,

  432.                         buffer_size,

  433.                         paNoFlag,  // Clipping is on...

  434.                         Render,

  435.                         this);

  436. 

  437.     if (err != paNoError) {

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

  439.         return -1;

  440.     } else {

  441.         // Only done when success

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

  443.     }

  444. }

  445. 

  446. } // end of namespace

  447. 

  448. #ifdef __cplusplus

  449. extern "C"

  450. {

  451. #endif

  452. 

  453. #include "JackExports.h"

  454. 

  455.     EXPORT jack_driver_desc_t* driver_get_descriptor() {

  456.         jack_driver_desc_t *desc;

  457.         unsigned int i;

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

  459. 

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

  461. 

  462.         desc->nparams = 13;

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

  464. 

  465.         i = 0;

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

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

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

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

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

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

  472. 

  473.         i++;

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

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

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

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

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

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

  480. 

  481.         i++;

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

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

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

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

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

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

  488. 

  489.         i++;

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

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

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

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

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

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

  496. 

  497.         i++;

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

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

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

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

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

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

  504. 

  505.         i++;

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

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

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

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

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

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

  512. 

  513.         i++;

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

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

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

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

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

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

  520. 

  521.         i++;

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

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

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

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

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

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

  528. 

  529.         i++;

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

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

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

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

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

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

  536. 

  537.         i++;

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

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

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

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

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

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

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

  545. 

  546.         i++;

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

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

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

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

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

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

  553. 

  554.         i++;

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

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

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

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

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

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

  561. 

  562.         i++;

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

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

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

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

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

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

  569. 

  570.         return desc;

  571.     }

  572. 

  573.     EXPORT Jack::JackDriverClientInterface* driver_initialize(Jack::JackEngineInterface* engine, Jack::JackSynchro** table, const JSList* params) {

  574.         jack_nframes_t srate = 44100;

  575.         jack_nframes_t frames_per_interrupt = 512;

  576.         int capture = FALSE;

  577.         int playback = FALSE;

  578.         int chan_in = 0;

  579.         int chan_out = 0;

  580.         bool monitor = false;

  581.         char* capture_pcm_name = "winmme";

  582.         char* playback_pcm_name = "winmme";

  583.         const JSList *node;

  584.         const jack_driver_param_t *param;

  585.         jack_nframes_t systemic_input_latency = 0;

  586.         jack_nframes_t systemic_output_latency = 0;

  587. 

  588.         for (node = params; node; node = jack_slist_next(node)) {

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

  590. 

  591.             switch (param->character) {

  592. 

  593.                 case 'd':

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

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

  596.                     break;

  597. 

  598.                 case 'D':

  599.                     capture = TRUE;

  600.                     playback = TRUE;

  601.                     break;

  602. 

  603.                 case 'c':

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

  605.                     break;

  606. 

  607.                 case 'i':

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

  609.                     break;

  610. 

  611.                 case 'o':

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

  613.                     break;

  614. 

  615.                 case 'C':

  616.                     capture = TRUE;

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

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

  619.                     }

  620.                     break;

  621. 

  622.                 case 'P':

  623.                     playback = TRUE;

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

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

  626.                     }

  627.                     break;

  628. 

  629.                 case 'm':

  630.                     monitor = param->value.i;

  631.                     break;

  632. 

  633.                 case 'r':

  634.                     srate = param->value.ui;

  635.                     break;

  636. 

  637.                 case 'p':

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

  639.                     break;

  640. 

  641.                 case 'I':

  642.                     systemic_input_latency = param->value.ui;

  643.                     break;

  644. 

  645.                 case 'O':

  646.                     systemic_output_latency = param->value.ui;

  647.                     break;

  648. 

  649.                 case 'l':

  650.                     Jack::DisplayDeviceNames();

  651.                     break;

  652.             }

  653.         }

  654. 

  655.         // duplex is the default

  656.         if (!capture && !playback) {

  657.             capture = TRUE;

  658.             playback = TRUE;

  659.         }

  660. 

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

  662.         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) {

  663.             return driver;

  664.         } else {

  665.             delete driver;

  666.             return NULL;

  667.         }

  668.     }

  669. 

  670. #ifdef __cplusplus

  671. }

  672. #endif