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

676 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. #ifdef __APPLE__

  25. #include "JackMachThread.h"

  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 "JackGraphManager.h"

  34. #include "JackError.h"

  35. #include "JackClientControl.h"

  36. #include "JackGlobals.h"

  37. #include <iostream>

  38. 

  39. namespace Jack

  40. {

  41. 

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

  43. {

  44.     static double standardSampleRates[] = {

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

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

  47.                                           };

  48.     int i, printCount;

  49.     PaError err;

  50. 

  51.     printCount = 0;

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

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

  54.         if (err == paFormatIsSupported) {

  55.             if (printCount == 0) {

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

  57.                 printCount = 1;

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

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

  60.                 printCount = 1;

  61.             } else {

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

  63.                 ++printCount;

  64.             }

  65.         }

  66.     }

  67.     if (!printCount)

  68.         printf("None\n");

  69.     else

  70.         printf("\n");

  71. }

  72. 

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

  74. {

  75.     const PaDeviceInfo* deviceInfo;

  76.     PaDeviceIndex numDevices = Pa_GetDeviceCount();

  77. 

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

  79.         deviceInfo = Pa_GetDeviceInfo(i);

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

  81.             *device = i;

  82.             *in_max = deviceInfo->maxInputChannels;

  83.             return true;

  84.         }

  85. 	}

  86. 

  87.     return false;

  88. }

  89. 

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

  91. {

  92.     const PaDeviceInfo* deviceInfo;

  93.     PaDeviceIndex numDevices = Pa_GetDeviceCount();

  94. 

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

  96.         deviceInfo = Pa_GetDeviceInfo(i);

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

  98.             *device = i;

  99.             *out_max = deviceInfo->maxOutputChannels;

  100.             return true;

  101.         }

  102.     }

  103. 

  104.     return false;

  105. }

  106. 

  107. static void DisplayDeviceNames()

  108. {

  109.     PaError err;

  110.     const PaDeviceInfo* deviceInfo;

  111.     PaStreamParameters inputParameters, outputParameters;

  112.     int defaultDisplayed;

  113. 

  114.     err = Pa_Initialize();

  115.     if (err != paNoError)

  116.         return ;

  117. 

  118.     PaDeviceIndex numDevices = Pa_GetDeviceCount();

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

  120. 

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

  122.         deviceInfo = Pa_GetDeviceInfo(i);

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

  124. 

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

  126.         defaultDisplayed = 0;

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

  128.             printf("[ Default Input");

  129.             defaultDisplayed = 1;

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

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

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

  133.             defaultDisplayed = 1;

  134.         }

  135. 

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

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

  138.             printf(" Default Output");

  139.             defaultDisplayed = 1;

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

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

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

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

  144.             defaultDisplayed = 1;

  145.         }

  146. 

  147.         if (defaultDisplayed)

  148.             printf(" ]\n");

  149. 

  150.         /* print device info fields */

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

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

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

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

  155.         /*

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

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

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

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

  160.         */

  161. 

  162. #ifdef WIN32

  163. #ifndef PA_NO_ASIO 

  164.         /* ASIO specific latency information */

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

  166.             long minLatency, maxLatency, preferredLatency, granularity;

  167. 

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

  169. 

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

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

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

  173. 

  174.             if (granularity == -1)

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

  176.             else

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

  178.         }

  179. #endif /* !PA_NO_ASIO */

  180. #endif /* WIN32 */

  181. 

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

  183. 

  184.         /* poll for standard sample rates */

  185.         inputParameters.device = i;

  186.         inputParameters.channelCount = deviceInfo->maxInputChannels;

  187.         inputParameters.sampleFormat = paInt16;

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

  189.         inputParameters.hostApiSpecificStreamInfo = NULL;

  190. 

  191.         outputParameters.device = i;

  192.         outputParameters.channelCount = deviceInfo->maxOutputChannels;

  193.         outputParameters.sampleFormat = paInt16;

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

  195.         outputParameters.hostApiSpecificStreamInfo = NULL;

  196. 

  197.         /*

  198.               if (inputParameters.channelCount > 0) {

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

  200.                   PrintSupportedStandardSampleRates(&inputParameters, NULL);

  201.               }

  202. 

  203.               if (outputParameters.channelCount > 0) {

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

  205.                   PrintSupportedStandardSampleRates(NULL, &outputParameters);

  206.               }

  207. 

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

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

  210.                           inputParameters.channelCount, outputParameters.channelCount );

  211.                   PrintSupportedStandardSampleRates(&inputParameters, &outputParameters);

  212.               }

  213.         */

  214.     }

  215. 

  216.     Pa_Terminate();

  217. }

  218. 

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

  220.                                 unsigned long framesPerBuffer,

  221.                                 const PaStreamCallbackTimeInfo* timeInfo,

  222.                                 PaStreamCallbackFlags statusFlags,

  223.                                 void* userData)

  224. {

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

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

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

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

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

  230. }

  231. 

  232. int JackPortAudioDriver::Read()

  233. {

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

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

  236.     }

  237.     return 0;

  238. }

  239. 

  240. int JackPortAudioDriver::Write()

  241. {

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

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

  244.     }

  245.     return 0;

  246. }

  247. 

  248. int JackPortAudioDriver::Open(jack_nframes_t nframes,

  249.                               jack_nframes_t samplerate,

  250.                               bool capturing,

  251.                               bool playing,

  252.                               int inchannels,

  253.                               int outchannels,

  254.                               bool monitor,

  255.                               const char* capture_driver_uid,

  256.                               const char* playback_driver_uid,

  257.                               jack_nframes_t capture_latency,

  258.                               jack_nframes_t playback_latency)

  259. {

  260.     PaError err;

  261.     PaStreamParameters inputParameters;

  262.     PaStreamParameters outputParameters;

  263.     const PaDeviceInfo* deviceInfo;

  264.     int in_max = 0;

  265.     int out_max = 0;

  266. 

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

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

  269. 

  270.     // Generic JackAudioDriver Open

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

  272.         return -1;

  273.     }

  274. 

  275.     err = Pa_Initialize();

  276.     if (err != paNoError) {

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

  278.         goto error;

  279.     }

  280. 

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

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

  283. 

  284.     if (capturing) {

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

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

  287.             fInputDevice = Pa_GetDefaultInputDevice();

  288. 			if (fInputDevice == paNoDevice)

  289. 				goto error;

  290.             deviceInfo = Pa_GetDeviceInfo(fInputDevice);

  291.             in_max = deviceInfo->maxInputChannels;

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

  293.         }

  294.     }

  295. 

  296.     if (inchannels > in_max) {

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

  298.         goto error;

  299.     }

  300. 

  301.     if (playing) {

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

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

  304. 			fOutputDevice = Pa_GetDefaultOutputDevice();

  305. 			if (fOutputDevice == paNoDevice)

  306. 				goto error;

  307.             deviceInfo = Pa_GetDeviceInfo(fOutputDevice);

  308.             out_max = deviceInfo->maxOutputChannels;

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

  310.         }

  311.     }

  312. 

  313.     if (outchannels > out_max) {

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

  315.         goto error;

  316.     }

  317. 

  318.     if (inchannels == 0) {

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

  320.         inchannels = in_max;

  321.     }

  322. 

  323.     if (outchannels == 0) {

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

  325.         outchannels = out_max;

  326.     }

  327. 

  328.     inputParameters.device = fInputDevice;

  329.     inputParameters.channelCount = inchannels;

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

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

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

  333.                                        : 0;

  334.     inputParameters.hostApiSpecificStreamInfo = NULL;

  335. 

  336.     outputParameters.device = fOutputDevice;

  337.     outputParameters.channelCount = outchannels;

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

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

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

  341.                                         : 0;

  342.     outputParameters.hostApiSpecificStreamInfo = NULL;

  343. 

  344.     err = Pa_OpenStream(&fStream,

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

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

  347.                         samplerate,

  348.                         nframes,

  349.                         paNoFlag,  // Clipping is on...

  350.                         Render,

  351.                         this);

  352.     if (err != paNoError) {

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

  354.         goto error;

  355.     }

  356. 

  357. #ifdef __APPLE__

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

  359.     fEngineControl->fComputation = 500 * 1000;

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

  361. #endif

  362. 

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

  364.     fCaptureChannels = inchannels;

  365.     fPlaybackChannels = outchannels;

  366. 

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

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

  369. 

  370.     strcpy(fCaptureDriverName, capture_driver_uid);

  371.     strcpy(fPlaybackDriverName, playback_driver_uid);

  372. 

  373.     return 0;

  374. 

  375. error:

  376.     Pa_Terminate();

  377.     return -1;

  378. }

  379. 

  380. int JackPortAudioDriver::Close()

  381. {

  382.     JackAudioDriver::Close();

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

  384.     Pa_CloseStream(fStream);

  385.     Pa_Terminate();

  386.     return 0;

  387. }

  388. 

  389. int JackPortAudioDriver::Start()

  390. {

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

  392.     JackAudioDriver::Start();

  393.     PaError err = Pa_StartStream(fStream);

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

  395. }

  396. 

  397. int JackPortAudioDriver::Stop()

  398. {

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

  400.     PaError err = Pa_StopStream(fStream);

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

  402. }

  403. 

  404. int JackPortAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  405. {

  406.     PaError err;

  407.     PaStreamParameters inputParameters;

  408.     PaStreamParameters outputParameters;

  409. 

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

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

  412.         return -1;

  413.     }

  414. 

  415.     inputParameters.device = fInputDevice;

  416.     inputParameters.channelCount = fCaptureChannels;

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

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

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

  420.                                        : 0;

  421.     inputParameters.hostApiSpecificStreamInfo = NULL;

  422. 

  423.     outputParameters.device = fOutputDevice;

  424.     outputParameters.channelCount = fPlaybackChannels;

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

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

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

  428.                                         : 0;

  429.     outputParameters.hostApiSpecificStreamInfo = NULL;

  430. 

  431.     err = Pa_OpenStream(&fStream,

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

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

  434.                         fEngineControl->fSampleRate,

  435.                         buffer_size,

  436.                         paNoFlag,  // Clipping is on...

  437.                         Render,

  438.                         this);

  439. 						

  440.     if (err != paNoError) {

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

  442.         return -1;

  443.     } else {

  444.         // Only done when success

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

  446.      }

  447. }

  448. 

  449. } // end of namespace

  450. 

  451. #ifdef __cplusplus

  452. extern "C"

  453. {

  454. #endif

  455. 

  456. #include "JackExports.h"

  457. 

  458.     EXPORT jack_driver_desc_t* driver_get_descriptor() {

  459.         jack_driver_desc_t *desc;

  460.         unsigned int i;

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

  462. 

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

  464. 

  465.         desc->nparams = 13;

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

  467. 

  468.         i = 0;

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

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

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

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

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

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

  475. 

  476.         i++;

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

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

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

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

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

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

  483. 

  484.         i++;

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

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

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

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

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

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

  491. 

  492.         i++;

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

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

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

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

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

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

  499. 

  500.         i++;

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

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

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

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

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

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

  507. 

  508.         i++;

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

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

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

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

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

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

  515. 

  516.         i++;

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

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

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

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

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

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

  523. 

  524.         i++;

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

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

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

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

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

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

  531. 

  532.         i++;

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

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

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

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

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

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

  539. 

  540.         i++;

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

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

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

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

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

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

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

  548. 

  549.         i++;

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

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

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

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

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

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

  556. 

  557.         i++;

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

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

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

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

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

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

  564. 

  565.         i++;

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

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

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

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

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

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

  572. 

  573.         return desc;

  574.     }

  575. 

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

  577.         jack_nframes_t srate = 44100;

  578.         jack_nframes_t frames_per_interrupt = 512;

  579.         int capture = FALSE;

  580.         int playback = FALSE;

  581.         int chan_in = 0;

  582.         int chan_out = 0;

  583.         bool monitor = false;

  584.         char* capture_pcm_name = "winmme";

  585.         char* playback_pcm_name = "winmme";

  586.         const JSList *node;

  587.         const jack_driver_param_t *param;

  588.         jack_nframes_t systemic_input_latency = 0;

  589.         jack_nframes_t systemic_output_latency = 0;

  590. 

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

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

  593. 

  594.             switch (param->character) {

  595. 

  596.                 case 'd':

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

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

  599.                     break;

  600. 

  601.                 case 'D':

  602.                     capture = TRUE;

  603.                     playback = TRUE;

  604.                     break;

  605. 

  606.                 case 'c':

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

  608.                     break;

  609. 

  610.                 case 'i':

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

  612.                     break;

  613. 

  614.                 case 'o':

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

  616.                     break;

  617. 

  618.                 case 'C':

  619.                     capture = TRUE;

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

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

  622.                     }

  623.                     break;

  624. 

  625.                 case 'P':

  626.                     playback = TRUE;

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

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

  629.                     }

  630.                     break;

  631. 

  632.                 case 'm':

  633.                     monitor = param->value.i;

  634.                     break;

  635. 

  636.                 case 'r':

  637.                     srate = param->value.ui;

  638.                     break;

  639. 

  640.                 case 'p':

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

  642.                     break;

  643. 

  644.                 case 'I':

  645.                     systemic_input_latency = param->value.ui;

  646.                     break;

  647. 

  648.                 case 'O':

  649.                     systemic_output_latency = param->value.ui;

  650.                     break;

  651. 

  652.                 case 'l':

  653.                     Jack::DisplayDeviceNames();

  654.                     break;

  655.             }

  656.         }

  657. 

  658.         // duplex is the default

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

  660.             capture = TRUE;

  661.             playback = TRUE;

  662.         }

  663. 

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

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

  666.             return driver;

  667.         } else {

  668.             delete driver;

  669.             return NULL;

  670.         }

  671.     }

  672. 

  673. #ifdef __cplusplus

  674. }

  675. #endif