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

677 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. #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 "pa_asio.h"

  29. #include "JackDriverLoader.h"

  30. #include "driver_interface.h"

  31. #include "JackPortAudioDriver.h"

  32. #include "JackEngineControl.h"

  33. #include "JackError.h"

  34. #include "JackTime.h"

  35. #include <iostream>

  36. #include <assert.h>

  37. 

  38. namespace Jack

  39. {

  40. 

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

  42. {

  43.     static double standardSampleRates[] = {

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

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

  46.                                           };

  47.     int i, printCount;

  48.     PaError err;

  49. 

  50.     printCount = 0;

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

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

  53.         if (err == paFormatIsSupported) {

  54.             if (printCount == 0) {

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

  56.                 printCount = 1;

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

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

  59.                 printCount = 1;

  60.             } else {

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

  62.                 ++printCount;

  63.             }

  64.         }

  65.     }

  66.     if (!printCount)

  67.         printf("None\n");

  68.     else

  69.         printf("\n");

  70. }

  71. 

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

  73. {

  74.     const PaDeviceInfo* deviceInfo;

  75.     PaDeviceIndex numDevices = Pa_GetDeviceCount();

  76. 

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

  78.         deviceInfo = Pa_GetDeviceInfo(i);

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

  80.             *device = i;

  81.             *in_max = deviceInfo->maxInputChannels;

  82.             return true;

  83.         }

  84.     }

  85. 

  86.     return false;

  87. }

  88. 

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

  90. {

  91.     const PaDeviceInfo* deviceInfo;

  92.     PaDeviceIndex numDevices = Pa_GetDeviceCount();

  93. 

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

  95.         deviceInfo = Pa_GetDeviceInfo(i);

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

  97.             *device = i;

  98.             *out_max = deviceInfo->maxOutputChannels;

  99.             return true;

  100.         }

  101.     }

  102. 

  103.     return false;

  104. }

  105. 

  106. static void DisplayDeviceNames()

  107. {

  108.     PaError err;

  109.     const PaDeviceInfo* deviceInfo;

  110.     PaStreamParameters inputParameters, outputParameters;

  111.     int defaultDisplayed;

  112. 

  113.     err = Pa_Initialize();

  114.     if (err != paNoError)

  115.         return ;

  116. 

  117.     PaDeviceIndex numDevices = Pa_GetDeviceCount();

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

  119. 

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

  121.         deviceInfo = Pa_GetDeviceInfo(i);

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

  123. 

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

  125.         defaultDisplayed = 0;

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

  127.             printf("[ Default Input");

  128.             defaultDisplayed = 1;

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

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

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

  132.             defaultDisplayed = 1;

  133.         }

  134. 

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

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

  137.             printf(" Default Output");

  138.             defaultDisplayed = 1;

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

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

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

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

  143.             defaultDisplayed = 1;

  144.         }

  145. 

  146.         if (defaultDisplayed)

  147.             printf(" ]\n");

  148. 

  149.         /* print device info fields */

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

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

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

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

  154.         /*

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

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

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

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

  159.         */

  160. 

  161. #ifdef WIN32

  162. #ifndef PA_NO_ASIO

  163.         /* ASIO specific latency information */

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

  165.             long minLatency, maxLatency, preferredLatency, granularity;

  166. 

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

  168. 

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

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

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

  172. 

  173.             if (granularity == -1)

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

  175.             else

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

  177.         }

  178. #endif /* !PA_NO_ASIO */

  179. #endif /* WIN32 */

  180. 

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

  182. 

  183.         /* poll for standard sample rates */

  184.         inputParameters.device = i;

  185.         inputParameters.channelCount = deviceInfo->maxInputChannels;

  186.         inputParameters.sampleFormat = paInt16;

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

  188.         inputParameters.hostApiSpecificStreamInfo = NULL;

  189. 

  190.         outputParameters.device = i;

  191.         outputParameters.channelCount = deviceInfo->maxOutputChannels;

  192.         outputParameters.sampleFormat = paInt16;

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

  194.         outputParameters.hostApiSpecificStreamInfo = NULL;

  195. 

  196.         /*

  197.               if (inputParameters.channelCount > 0) {

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

  199.                   PrintSupportedStandardSampleRates(&inputParameters, NULL);

  200.               }

  201. 

  202.               if (outputParameters.channelCount > 0) {

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

  204.                   PrintSupportedStandardSampleRates(NULL, &outputParameters);

  205.               }

  206. 

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

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

  209.                           inputParameters.channelCount, outputParameters.channelCount );

  210.                   PrintSupportedStandardSampleRates(&inputParameters, &outputParameters);

  211.               }

  212.         */

  213.     }

  214. 

  215.     Pa_Terminate();

  216. }

  217. 

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

  219.                                 unsigned long framesPerBuffer,

  220.                                 const PaStreamCallbackTimeInfo* timeInfo,

  221.                                 PaStreamCallbackFlags statusFlags,

  222.                                 void* userData)

  223. {

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

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

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

  227.     // Setup threadded based log function

  228.     set_threaded_log_function();

  229.     driver->CycleTakeTime();

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

  231. }

  232. 

  233. int JackPortAudioDriver::Read()

  234. {

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

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

  237.     }

  238.     return 0;

  239. }

  240. 

  241. int JackPortAudioDriver::Write()

  242. {

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

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

  245.     }

  246.     return 0;

  247. }

  248. 

  249. int JackPortAudioDriver::Open(jack_nframes_t nframes,

  250.                               jack_nframes_t samplerate,

  251.                               bool capturing,

  252.                               bool playing,

  253.                               int inchannels,

  254.                               int outchannels,

  255.                               bool monitor,

  256.                               const char* capture_driver_uid,

  257.                               const char* playback_driver_uid,

  258.                               jack_nframes_t capture_latency,

  259.                               jack_nframes_t playback_latency)

  260. {

  261.     PaError err;

  262.     PaStreamParameters inputParameters;

  263.     PaStreamParameters outputParameters;

  264.     const PaDeviceInfo* deviceInfo;

  265.     int in_max = 0;

  266.     int out_max = 0;

  267. 

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

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

  270. 

  271.     // Generic JackAudioDriver Open

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

  273.         return -1;

  274.     }

  275. 

  276.     err = Pa_Initialize();

  277.     if (err != paNoError) {

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

  279.         goto error;

  280.     }

  281. 

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

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

  284. 

  285.     if (capturing) {

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

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

  288.             fInputDevice = Pa_GetDefaultInputDevice();

  289.             if (fInputDevice == paNoDevice)

  290.                 goto error;

  291.             deviceInfo = Pa_GetDeviceInfo(fInputDevice);

  292.             in_max = deviceInfo->maxInputChannels;

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

  294.         }

  295.     }

  296. 

  297.     if (inchannels > in_max) {

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

  299.         goto error;

  300.     }

  301. 

  302.     if (playing) {

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

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

  305.             fOutputDevice = Pa_GetDefaultOutputDevice();

  306.             if (fOutputDevice == paNoDevice)

  307.                 goto error;

  308.             deviceInfo = Pa_GetDeviceInfo(fOutputDevice);

  309.             out_max = deviceInfo->maxOutputChannels;

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

  311.         }

  312.     }

  313. 

  314.     if (outchannels > out_max) {

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

  316.         goto error;

  317.     }

  318. 

  319.     if (inchannels == 0) {

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

  321.         inchannels = in_max;

  322.     }

  323. 

  324.     if (outchannels == 0) {

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

  326.         outchannels = out_max;

  327.     }

  328. 

  329.     inputParameters.device = fInputDevice;

  330.     inputParameters.channelCount = inchannels;

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

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

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

  334.                                        : 0;

  335.     inputParameters.hostApiSpecificStreamInfo = NULL;

  336. 

  337.     outputParameters.device = fOutputDevice;

  338.     outputParameters.channelCount = outchannels;

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

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

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

  342.                                         : 0;

  343.     outputParameters.hostApiSpecificStreamInfo = NULL;

  344. 

  345.     err = Pa_OpenStream(&fStream,

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

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

  348.                         samplerate,

  349.                         nframes,

  350.                         paNoFlag,  // Clipping is on...

  351.                         Render,

  352.                         this);

  353.     if (err != paNoError) {

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

  355.         goto error;

  356.     }

  357. 

  358. #ifdef __APPLE__

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

  360.     fEngineControl->fComputation = 500 * 1000;

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

  362. #endif

  363. 

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

  365.     fCaptureChannels = inchannels;

  366.     fPlaybackChannels = outchannels;

  367. 

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

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

  370. 

  371.     strcpy(fCaptureDriverName, capture_driver_uid);

  372.     strcpy(fPlaybackDriverName, playback_driver_uid);

  373. 

  374.     return 0;

  375. 

  376. error:

  377.     Pa_Terminate();

  378.     return -1;

  379. }

  380. 

  381. int JackPortAudioDriver::Close()

  382. {

  383.     JackAudioDriver::Close();

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

  385.     Pa_CloseStream(fStream);

  386.     Pa_Terminate();

  387.     return 0;

  388. }

  389. 

  390. int JackPortAudioDriver::Start()

  391. {

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

  393.     JackAudioDriver::Start();

  394.     PaError err = Pa_StartStream(fStream);

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

  396. }

  397. 

  398. int JackPortAudioDriver::Stop()

  399. {

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

  401.     PaError err = Pa_StopStream(fStream);

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

  403. }

  404. 

  405. int JackPortAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  406. {

  407.     PaError err;

  408.     PaStreamParameters inputParameters;

  409.     PaStreamParameters outputParameters;

  410. 

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

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

  413.         return -1;

  414.     }

  415. 

  416.     inputParameters.device = fInputDevice;

  417.     inputParameters.channelCount = fCaptureChannels;

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

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

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

  421.                                        : 0;

  422.     inputParameters.hostApiSpecificStreamInfo = NULL;

  423. 

  424.     outputParameters.device = fOutputDevice;

  425.     outputParameters.channelCount = fPlaybackChannels;

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

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

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

  429.                                         : 0;

  430.     outputParameters.hostApiSpecificStreamInfo = NULL;

  431. 

  432.     err = Pa_OpenStream(&fStream,

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

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

  435.                         fEngineControl->fSampleRate,

  436.                         buffer_size,

  437.                         paNoFlag,  // Clipping is on...

  438.                         Render,

  439.                         this);

  440. 

  441.     if (err != paNoError) {

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

  443.         return -1;

  444.     } else {

  445.         // Only done when success

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

  447.     }

  448. }

  449. 

  450. } // end of namespace

  451. 

  452. #ifdef __cplusplus

  453. extern "C"

  454. {

  455. #endif

  456. 

  457. #include "JackExports.h"

  458. 

  459.     EXPORT jack_driver_desc_t* driver_get_descriptor() {

  460.         jack_driver_desc_t *desc;

  461.         unsigned int i;

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

  463. 

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

  465. 

  466.         desc->nparams = 13;

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

  468. 

  469.         i = 0;

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

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

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

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

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

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

  476. 

  477.         i++;

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

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

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

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

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

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

  484. 

  485.         i++;

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

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

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

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

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

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

  492. 

  493.         i++;

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

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

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

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

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

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

  500. 

  501.         i++;

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

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

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

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

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

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

  508. 

  509.         i++;

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

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

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

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

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

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

  516. 

  517.         i++;

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

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

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

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

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

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

  524. 

  525.         i++;

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

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

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

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

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

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

  532. 

  533.         i++;

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

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

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

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

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

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

  540. 

  541.         i++;

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

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

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

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

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

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

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

  549. 

  550.         i++;

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

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

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

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

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

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

  557. 

  558.         i++;

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

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

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

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

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

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

  565. 

  566.         i++;

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

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

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

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

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

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

  573. 

  574.         return desc;

  575.     }

  576. 

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

  578.         jack_nframes_t srate = 44100;

  579.         jack_nframes_t frames_per_interrupt = 512;

  580.         int capture = FALSE;

  581.         int playback = FALSE;

  582.         int chan_in = 0;

  583.         int chan_out = 0;

  584.         bool monitor = false;

  585.         char* capture_pcm_name = "winmme";

  586.         char* playback_pcm_name = "winmme";

  587.         const JSList *node;

  588.         const jack_driver_param_t *param;

  589.         jack_nframes_t systemic_input_latency = 0;

  590.         jack_nframes_t systemic_output_latency = 0;

  591. 

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

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

  594. 

  595.             switch (param->character) {

  596. 

  597.                 case 'd':

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

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

  600.                     break;

  601. 

  602.                 case 'D':

  603.                     capture = TRUE;

  604.                     playback = TRUE;

  605.                     break;

  606. 

  607.                 case 'c':

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

  609.                     break;

  610. 

  611.                 case 'i':

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

  613.                     break;

  614. 

  615.                 case 'o':

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

  617.                     break;

  618. 

  619.                 case 'C':

  620.                     capture = TRUE;

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

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

  623.                     }

  624.                     break;

  625. 

  626.                 case 'P':

  627.                     playback = TRUE;

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

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

  630.                     }

  631.                     break;

  632. 

  633.                 case 'm':

  634.                     monitor = param->value.i;

  635.                     break;

  636. 

  637.                 case 'r':

  638.                     srate = param->value.ui;

  639.                     break;

  640. 

  641.                 case 'p':

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

  643.                     break;

  644. 

  645.                 case 'I':

  646.                     systemic_input_latency = param->value.ui;

  647.                     break;

  648. 

  649.                 case 'O':

  650.                     systemic_output_latency = param->value.ui;

  651.                     break;

  652. 

  653.                 case 'l':

  654.                     Jack::DisplayDeviceNames();

  655.                     break;

  656.             }

  657.         }

  658. 

  659.         // duplex is the default

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

  661.             capture = TRUE;

  662.             playback = TRUE;

  663.         }

  664. 

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

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

  667.             return driver;

  668.         } else {

  669.             delete driver;

  670.             return NULL;

  671.         }

  672.     }

  673. 

  674. #ifdef __cplusplus

  675. }

  676. #endif