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

670 lines
25KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2004-2006 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. 

  33. namespace Jack

  34. {

  35. 

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

  37. {

  38.     static double standardSampleRates[] = {

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

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

  41.                                           };

  42.     int i, printCount;

  43.     PaError err;

  44. 

  45.     printCount = 0;

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

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

  48.         if (err == paFormatIsSupported) {

  49.             if (printCount == 0) {

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

  51.                 printCount = 1;

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

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

  54.                 printCount = 1;

  55.             } else {

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

  57.                 ++printCount;

  58.             }

  59.         }

  60.     }

  61.     if (!printCount)

  62.         printf("None\n");

  63.     else

  64.         printf("\n");

  65. }

  66. 

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

  68. {

  69.     const PaDeviceInfo* deviceInfo;

  70.     PaDeviceIndex numDevices = Pa_GetDeviceCount();

  71. 

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

  73.         deviceInfo = Pa_GetDeviceInfo(i);

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

  75.             *device = i;

  76.             *in_max = deviceInfo->maxInputChannels;

  77.             return true;

  78.         }

  79. 	}

  80. 

  81.     return false;

  82. }

  83. 

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

  85. {

  86.     const PaDeviceInfo* deviceInfo;

  87.     PaDeviceIndex numDevices = Pa_GetDeviceCount();

  88. 

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

  90.         deviceInfo = Pa_GetDeviceInfo(i);

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

  92.             *device = i;

  93.             *out_max = deviceInfo->maxOutputChannels;

  94.             return true;

  95.         }

  96.     }

  97. 

  98.     return false;

  99. }

  100. 

  101. static void DisplayDeviceNames()

  102. {

  103.     PaError err;

  104.     const PaDeviceInfo* deviceInfo;

  105.     PaStreamParameters inputParameters, outputParameters;

  106.     int defaultDisplayed;

  107. 

  108.     err = Pa_Initialize();

  109.     if (err != paNoError)

  110.         return ;

  111. 

  112.     PaDeviceIndex numDevices = Pa_GetDeviceCount();

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

  114. 

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

  116.         deviceInfo = Pa_GetDeviceInfo(i);

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

  118. 

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

  120.         defaultDisplayed = 0;

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

  122.             printf("[ Default Input");

  123.             defaultDisplayed = 1;

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

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

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

  127.             defaultDisplayed = 1;

  128.         }

  129. 

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

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

  132.             printf(" Default Output");

  133.             defaultDisplayed = 1;

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

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

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

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

  138.             defaultDisplayed = 1;

  139.         }

  140. 

  141.         if (defaultDisplayed)

  142.             printf(" ]\n");

  143. 

  144.         /* print device info fields */

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

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

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

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

  149.         /*

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

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

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

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

  154.         */

  155. 

  156. #ifdef WIN32

  157. #ifndef PA_NO_ASIO 

  158.         /* ASIO specific latency information */

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

  160.             long minLatency, maxLatency, preferredLatency, granularity;

  161. 

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

  163. 

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

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

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

  167. 

  168.             if (granularity == -1)

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

  170.             else

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

  172.         }

  173. #endif /* !PA_NO_ASIO */

  174. #endif /* WIN32 */

  175. 

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

  177. 

  178.         /* poll for standard sample rates */

  179.         inputParameters.device = i;

  180.         inputParameters.channelCount = deviceInfo->maxInputChannels;

  181.         inputParameters.sampleFormat = paInt16;

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

  183.         inputParameters.hostApiSpecificStreamInfo = NULL;

  184. 

  185.         outputParameters.device = i;

  186.         outputParameters.channelCount = deviceInfo->maxOutputChannels;

  187.         outputParameters.sampleFormat = paInt16;

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

  189.         outputParameters.hostApiSpecificStreamInfo = NULL;

  190. 

  191.         /*

  192.               if (inputParameters.channelCount > 0) {

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

  194.                   PrintSupportedStandardSampleRates(&inputParameters, NULL);

  195.               }

  196. 

  197.               if (outputParameters.channelCount > 0) {

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

  199.                   PrintSupportedStandardSampleRates(NULL, &outputParameters);

  200.               }

  201. 

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

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

  204.                           inputParameters.channelCount, outputParameters.channelCount );

  205.                   PrintSupportedStandardSampleRates(&inputParameters, &outputParameters);

  206.               }

  207.         */

  208.     }

  209. 

  210.     Pa_Terminate();

  211. }

  212. 

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

  214.                                 unsigned long framesPerBuffer,

  215.                                 const PaStreamCallbackTimeInfo* timeInfo,

  216.                                 PaStreamCallbackFlags statusFlags,

  217.                                 void* userData)

  218. {

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

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

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

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

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

  224. }

  225. 

  226. int JackPortAudioDriver::Read()

  227. {

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

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

  230.     }

  231.     return 0;

  232. }

  233. 

  234. int JackPortAudioDriver::Write()

  235. {

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

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

  238.     }

  239.     return 0;

  240. }

  241. 

  242. int JackPortAudioDriver::Open(jack_nframes_t nframes,

  243.                               jack_nframes_t samplerate,

  244.                               bool capturing,

  245.                               bool playing,

  246.                               int inchannels,

  247.                               int outchannels,

  248.                               bool monitor,

  249.                               const char* capture_driver_uid,

  250.                               const char* playback_driver_uid,

  251.                               jack_nframes_t capture_latency,

  252.                               jack_nframes_t playback_latency)

  253. {

  254.     PaError err;

  255.     PaStreamParameters inputParameters;

  256.     PaStreamParameters outputParameters;

  257.     const PaDeviceInfo* deviceInfo;

  258.     int in_max = 0;

  259.     int out_max = 0;

  260. 

  261.     JackLog("JackPortAudioDriver::Open nframes = %ld in = %ld out = %ld capture name = %s playback name = %s samplerate = %ld\n",

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

  263. 

  264.     // Generic JackAudioDriver Open

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

  266.         return -1;

  267.     }

  268. 

  269.     err = Pa_Initialize();

  270.     if (err != paNoError) {

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

  272.         goto error;

  273.     }

  274. 

  275.     JackLog("JackPortAudioDriver::Pa_GetDefaultInputDevice %ld\n", Pa_GetDefaultInputDevice());

  276.     JackLog("JackPortAudioDriver::Pa_GetDefaultOutputDevice %ld\n", Pa_GetDefaultOutputDevice());

  277. 

  278.     if (capturing) {

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

  280. 			JackLog("JackPortAudioDriver::GetInputDeviceFromName cannot open %s\n", capture_driver_uid);

  281.             fInputDevice = Pa_GetDefaultInputDevice();

  282. 			if (fInputDevice == paNoDevice)

  283. 				goto error;

  284.             deviceInfo = Pa_GetDeviceInfo(fInputDevice);

  285.             in_max = deviceInfo->maxInputChannels;

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

  287.         }

  288.     }

  289. 

  290.     if (inchannels > in_max) {

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

  292.         goto error;

  293.     }

  294. 

  295.     if (playing) {

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

  297.             JackLog("JackPortAudioDriver::GetOutputDeviceFromName cannot open %s\n", playback_driver_uid);

  298. 			fOutputDevice = Pa_GetDefaultOutputDevice();

  299. 			if (fOutputDevice == paNoDevice)

  300. 				goto error;

  301.             deviceInfo = Pa_GetDeviceInfo(fOutputDevice);

  302.             out_max = deviceInfo->maxOutputChannels;

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

  304.         }

  305.     }

  306. 

  307.     if (outchannels > out_max) {

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

  309.         goto error;

  310.     }

  311. 

  312.     if (inchannels == 0) {

  313.         JackLog("JackPortAudioDriver::Open setup max in channels = %ld\n", in_max);

  314.         inchannels = in_max;

  315.     }

  316. 

  317.     if (outchannels == 0) {

  318.         JackLog("JackPortAudioDriver::Open setup max out channels = %ld\n", out_max);

  319.         outchannels = out_max;

  320.     }

  321. 

  322.     inputParameters.device = fInputDevice;

  323.     inputParameters.channelCount = inchannels;

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

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

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

  327.                                        : 0;

  328.     inputParameters.hostApiSpecificStreamInfo = NULL;

  329. 

  330.     outputParameters.device = fOutputDevice;

  331.     outputParameters.channelCount = outchannels;

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

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

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

  335.                                         : 0;

  336.     outputParameters.hostApiSpecificStreamInfo = NULL;

  337. 

  338.     err = Pa_OpenStream(&fStream,

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

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

  341.                         samplerate,

  342.                         nframes,

  343.                         paNoFlag,  // Clipping is on...

  344.                         Render,

  345.                         this);

  346.     if (err != paNoError) {

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

  348.         goto error;

  349.     }

  350. 

  351. #ifdef __APPLE__

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

  353.     fEngineControl->fComputation = 500 * 1000;

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

  355. #endif

  356. 

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

  358.     fCaptureChannels = inchannels;

  359.     fPlaybackChannels = outchannels;

  360. 

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

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

  363. 

  364.     strcpy(fCaptureDriverName, capture_driver_uid);

  365.     strcpy(fPlaybackDriverName, playback_driver_uid);

  366. 

  367.     return 0;

  368. 

  369. error:

  370.     Pa_Terminate();

  371.     return -1;

  372. }

  373. 

  374. int JackPortAudioDriver::Close()

  375. {

  376.     JackAudioDriver::Close();

  377. 	JackLog("JackPortAudioDriver::Close\n");

  378.     Pa_CloseStream(fStream);

  379.     Pa_Terminate();

  380.     return 0;

  381. }

  382. 

  383. int JackPortAudioDriver::Start()

  384. {

  385.     JackLog("JackPortAudioDriver::Start\n");

  386.     JackAudioDriver::Start();

  387.     PaError err = Pa_StartStream(fStream);

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

  389. }

  390. 

  391. int JackPortAudioDriver::Stop()

  392. {

  393.     JackLog("JackPortAudioDriver::Stop\n");

  394.     PaError err = Pa_StopStream(fStream);

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

  396. }

  397. 

  398. int JackPortAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  399. {

  400.     PaError err;

  401.     PaStreamParameters inputParameters;

  402.     PaStreamParameters outputParameters;

  403. 

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

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

  406.         return -1;

  407.     }

  408. 

  409.     inputParameters.device = fInputDevice;

  410.     inputParameters.channelCount = fCaptureChannels;

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

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

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

  414.                                        : 0;

  415.     inputParameters.hostApiSpecificStreamInfo = NULL;

  416. 

  417.     outputParameters.device = fOutputDevice;

  418.     outputParameters.channelCount = fPlaybackChannels;

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

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

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

  422.                                         : 0;

  423.     outputParameters.hostApiSpecificStreamInfo = NULL;

  424. 

  425.     err = Pa_OpenStream(&fStream,

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

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

  428.                         fEngineControl->fSampleRate,

  429.                         buffer_size,

  430.                         paNoFlag,  // Clipping is on...

  431.                         Render,

  432.                         this);

  433. 						

  434.     if (err != paNoError) {

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

  436.         return -1;

  437.     } else {

  438.         // Only done when success

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

  440.      }

  441. }

  442. 

  443. } // end of namespace

  444. 

  445. #ifdef __cplusplus

  446. extern "C"

  447. {

  448. #endif

  449. 

  450. #include "JackExports.h"

  451. 

  452.     EXPORT jack_driver_desc_t* driver_get_descriptor() {

  453.         jack_driver_desc_t *desc;

  454.         unsigned int i;

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

  456. 

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

  458. 

  459.         desc->nparams = 13;

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

  461. 

  462.         i = 0;

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

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

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

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

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

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

  469. 

  470.         i++;

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

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

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

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

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

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

  477. 

  478.         i++;

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

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

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

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

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

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

  485. 

  486.         i++;

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

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

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

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

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

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

  493. 

  494.         i++;

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

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

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

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

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

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

  501. 

  502.         i++;

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

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

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

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

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

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

  509. 

  510.         i++;

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

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

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

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

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

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

  517. 

  518.         i++;

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

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

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

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

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

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

  525. 

  526.         i++;

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

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

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

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

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

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

  533. 

  534.         i++;

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

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

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

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

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

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

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

  542. 

  543.         i++;

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

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

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

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

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

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

  550. 

  551.         i++;

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

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

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

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

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

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

  558. 

  559.         i++;

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

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

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

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

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

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

  566. 

  567.         return desc;

  568.     }

  569. 

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

  571.         jack_nframes_t srate = 44100;

  572.         jack_nframes_t frames_per_interrupt = 512;

  573.         int capture = FALSE;

  574.         int playback = FALSE;

  575.         int chan_in = 0;

  576.         int chan_out = 0;

  577.         bool monitor = false;

  578.         char* capture_pcm_name = "winmme";

  579.         char* playback_pcm_name = "winmme";

  580.         const JSList *node;

  581.         const jack_driver_param_t *param;

  582.         jack_nframes_t systemic_input_latency = 0;

  583.         jack_nframes_t systemic_output_latency = 0;

  584. 

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

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

  587. 

  588.             switch (param->character) {

  589. 

  590.                 case 'd':

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

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

  593.                     break;

  594. 

  595.                 case 'D':

  596.                     capture = TRUE;

  597.                     playback = TRUE;

  598.                     break;

  599. 

  600.                 case 'c':

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

  602.                     break;

  603. 

  604.                 case 'i':

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

  606.                     break;

  607. 

  608.                 case 'o':

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

  610.                     break;

  611. 

  612.                 case 'C':

  613.                     capture = TRUE;

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

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

  616.                     }

  617.                     break;

  618. 

  619.                 case 'P':

  620.                     playback = TRUE;

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

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

  623.                     }

  624.                     break;

  625. 

  626.                 case 'm':

  627.                     monitor = param->value.i;

  628.                     break;

  629. 

  630.                 case 'r':

  631.                     srate = param->value.ui;

  632.                     break;

  633. 

  634.                 case 'p':

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

  636.                     break;

  637. 

  638.                 case 'I':

  639.                     systemic_input_latency = param->value.ui;

  640.                     break;

  641. 

  642.                 case 'O':

  643.                     systemic_output_latency = param->value.ui;

  644.                     break;

  645. 

  646.                 case 'l':

  647.                     Jack::DisplayDeviceNames();

  648.                     break;

  649.             }

  650.         }

  651. 

  652.         // duplex is the default

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

  654.             capture = TRUE;

  655.             playback = TRUE;

  656.         }

  657. 

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

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

  660.             return driver;

  661.         } else {

  662.             delete driver;

  663.             return NULL;

  664.         }

  665.     }

  666. 

  667. #ifdef __cplusplus

  668. }

  669. #endif