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.
1496 Commits
8 Branches
44MB
Tree: 8902893408
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8902893408'
${ noResults }
jack2/macosx/coreaudio/JackCoreAudioAdapter.cpp

1111 lines
40KB
Raw Blame History 

  1. /*

  2. Copyright (C) 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. #include "JackCoreAudioAdapter.h"

  21. #include "JackError.h"

  22. #include <unistd.h>

  23. 

  24. namespace Jack

  25. {

  26. 

  27. static OSStatus DisplayDeviceNames()

  28. {

  29.     UInt32 size;

  30.     Boolean isWritable;

  31.     int i, deviceNum;

  32.     OSStatus err;

  33.     CFStringRef UIname;

  34. 

  35.     err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size, &isWritable);

  36.     if (err != noErr)

  37.         return err;

  38. 

  39.     deviceNum = size / sizeof(AudioDeviceID);

  40.     AudioDeviceID devices[deviceNum];

  41. 

  42.     err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &size, devices);

  43.     if (err != noErr)

  44.         return err;

  45. 

  46.     for (i = 0; i < deviceNum; i++) {

  47.         char device_name[256];

  48.         char internal_name[256];

  49. 

  50.         size = sizeof(CFStringRef);

  51.         UIname = NULL;

  52.         err = AudioDeviceGetProperty(devices[i], 0, false, kAudioDevicePropertyDeviceUID, &size, &UIname);

  53.         if (err == noErr) {

  54.             CFStringGetCString(UIname, internal_name, 256, CFStringGetSystemEncoding());

  55.         } else {

  56.             goto error;

  57.         }

  58. 

  59.         size = 256;

  60.         err = AudioDeviceGetProperty(devices[i], 0, false, kAudioDevicePropertyDeviceName, &size, device_name);

  61.         if (err != noErr)

  62.             return err;

  63. 

  64.         jack_info("Device name = \'%s\', internal_name = \'%s\' (to be used as -C, -P, or -d parameter)", device_name, internal_name);

  65.     }

  66. 

  67.     return noErr;

  68. 

  69. error:

  70.     if (UIname != NULL)

  71.         CFRelease(UIname);

  72.     return err;

  73. }

  74. 

  75. static void printError(OSStatus err)

  76. {

  77.     switch (err) {

  78.         case kAudioHardwareNoError:

  79.             jack_log("error code : kAudioHardwareNoError");

  80.             break;

  81.         case kAudioConverterErr_FormatNotSupported:

  82.             jack_log("error code : kAudioConverterErr_FormatNotSupported");

  83.             break;

  84.         case kAudioConverterErr_OperationNotSupported:

  85.             jack_log("error code : kAudioConverterErr_OperationNotSupported");

  86.             break;

  87.         case kAudioConverterErr_PropertyNotSupported:

  88.             jack_log("error code : kAudioConverterErr_PropertyNotSupported");

  89.             break;

  90.         case kAudioConverterErr_InvalidInputSize:

  91.             jack_log("error code : kAudioConverterErr_InvalidInputSize");

  92.             break;

  93.         case kAudioConverterErr_InvalidOutputSize:

  94.             jack_log("error code : kAudioConverterErr_InvalidOutputSize");

  95.             break;

  96.         case kAudioConverterErr_UnspecifiedError:

  97.             jack_log("error code : kAudioConverterErr_UnspecifiedError");

  98.             break;

  99.         case kAudioConverterErr_BadPropertySizeError:

  100.             jack_log("error code : kAudioConverterErr_BadPropertySizeError");

  101.             break;

  102.         case kAudioConverterErr_RequiresPacketDescriptionsError:

  103.             jack_log("error code : kAudioConverterErr_RequiresPacketDescriptionsError");

  104.             break;

  105.         case kAudioConverterErr_InputSampleRateOutOfRange:

  106.             jack_log("error code : kAudioConverterErr_InputSampleRateOutOfRange");

  107.             break;

  108.         case kAudioConverterErr_OutputSampleRateOutOfRange:

  109.             jack_log("error code : kAudioConverterErr_OutputSampleRateOutOfRange");

  110.             break;

  111.         case kAudioHardwareNotRunningError:

  112.             jack_log("error code : kAudioHardwareNotRunningError");

  113.             break;

  114.         case kAudioHardwareUnknownPropertyError:

  115.             jack_log("error code : kAudioHardwareUnknownPropertyError");

  116.             break;

  117.         case kAudioHardwareIllegalOperationError:

  118.             jack_log("error code : kAudioHardwareIllegalOperationError");

  119.             break;

  120.         case kAudioHardwareBadDeviceError:

  121.             jack_log("error code : kAudioHardwareBadDeviceError");

  122.             break;

  123.         case kAudioHardwareBadStreamError:

  124.             jack_log("error code : kAudioHardwareBadStreamError");

  125.             break;

  126.         case kAudioDeviceUnsupportedFormatError:

  127.             jack_log("error code : kAudioDeviceUnsupportedFormatError");

  128.             break;

  129.         case kAudioDevicePermissionsError:

  130.             jack_log("error code : kAudioDevicePermissionsError");

  131.             break;

  132.         case kAudioHardwareBadObjectError:

  133.             jack_log("error code : kAudioHardwareBadObjectError");

  134.             break;

  135.         case kAudioHardwareUnsupportedOperationError:

  136.             jack_log("error code : kAudioHardwareUnsupportedOperationError");

  137.             break;

  138.         default:

  139.             jack_log("error code : unknown");

  140.             break;

  141.     }

  142. }

  143. 

  144. OSStatus JackCoreAudioAdapter::SRNotificationCallback(AudioDeviceID inDevice,

  145.                                                         UInt32 inChannel,

  146.                                                         Boolean	isInput,

  147.                                                         AudioDevicePropertyID inPropertyID,

  148.                                                         void* inClientData)

  149. {

  150.     JackCoreAudioAdapter* driver = static_cast<JackCoreAudioAdapter*>(inClientData);

  151. 

  152.     switch (inPropertyID) {

  153. 

  154.         case kAudioDevicePropertyNominalSampleRate: {

  155.             jack_log("JackCoreAudioDriver::SRNotificationCallback kAudioDevicePropertyNominalSampleRate");

  156.             driver->fState = true;

  157.             break;

  158.         }

  159.     }

  160. 

  161.     return noErr;

  162. }

  163. 

  164. // A better implementation would try to recover in case of hardware device change (see HALLAB HLFilePlayerWindowControllerAudioDevicePropertyListenerProc code)

  165. 

  166. OSStatus JackCoreAudioAdapter::DeviceNotificationCallback(AudioDeviceID inDevice,

  167.         UInt32 inChannel,

  168.         Boolean	isInput,

  169.         AudioDevicePropertyID inPropertyID,

  170.         void* inClientData)

  171. {

  172.     JackCoreAudioAdapter* driver = (JackCoreAudioAdapter*)inClientData;

  173.          

  174.     switch (inPropertyID) {

  175. 

  176.         case kAudioDevicePropertyStreamConfiguration:

  177.         case kAudioDevicePropertyNominalSampleRate: {

  178. 

  179.             UInt32 outSize = sizeof(Float64);

  180.             Float64 sampleRate;

  181.             int in_nChannels = 0;

  182.             int out_nChannels = 0;

  183.             char capture_driver_name[256];

  184.             char playback_driver_name[256];

  185.     

  186.             // Stop and restart

  187.             AudioOutputUnitStop(driver->fAUHAL);

  188.             driver->RemoveListeners();

  189.             driver->CloseAUHAL();

  190. 

  191.             OSStatus err = AudioDeviceGetProperty(driver->fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);

  192.             if (err != noErr) {

  193.                 jack_error("Cannot get current sample rate");

  194.                 printError(err);

  195.             }

  196.             jack_log("JackCoreAudioDriver::DeviceNotificationCallback kAudioDevicePropertyNominalSampleRate %ld", long(sampleRate));

  197. 

  198.             if (driver->SetupDevices(driver->fCaptureUID, driver->fPlaybackUID, capture_driver_name, playback_driver_name) < 0)

  199.                 return -1;

  200. 

  201.             if (driver->SetupChannels(driver->fCapturing, driver->fPlaying, driver->fCaptureChannels, driver->fPlaybackChannels, in_nChannels, out_nChannels, false) < 0)

  202.                 return -1;

  203. 

  204.             if (driver->SetupBufferSizeAndSampleRate(driver->fAdaptedBufferSize, sampleRate)  < 0)

  205.                 return -1;

  206.                 

  207.             driver->SetAdaptedSampleRate(sampleRate);

  208. 

  209.             if (driver->OpenAUHAL(driver->fCapturing,

  210.                                   driver->fPlaying,

  211.                                   driver->fCaptureChannels,

  212.                                   driver->fPlaybackChannels,

  213.                                   in_nChannels,

  214.                                   out_nChannels,

  215.                                   driver->fAdaptedBufferSize,

  216.                                   sampleRate,

  217.                                   false) < 0)

  218.                 goto error;

  219. 

  220.             if (driver->AddListeners() < 0)

  221.                 goto error;

  222.        

  223.             AudioOutputUnitStart(driver->fAUHAL);

  224.             return noErr;

  225. error:

  226.             driver->CloseAUHAL();

  227.             break;

  228.         }

  229.     }

  230.     return noErr;

  231. }

  232. 

  233. int JackCoreAudioAdapter::AddListeners()

  234. {

  235.     OSStatus err = noErr;

  236. 

  237.     // Add listeners

  238.  

  239.     err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioHardwarePropertyDevices, DeviceNotificationCallback, this);

  240.     if (err != noErr) {

  241.         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioHardwarePropertyDevices");

  242.         printError(err);

  243.         return -1;

  244.     }

  245. 

  246.     err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, DeviceNotificationCallback, this);

  247.     if (err != noErr) {

  248.         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyNominalSampleRate");

  249.         printError(err);

  250.         return -1;

  251.     }

  252. 

  253.     err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyDeviceIsRunning, DeviceNotificationCallback, this);

  254.     if (err != noErr) {

  255.         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyDeviceIsRunning");

  256.         printError(err);

  257.         return -1;

  258.     }

  259. 

  260.     err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyStreamConfiguration, DeviceNotificationCallback, this);

  261.     if (err != noErr) {

  262.         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyStreamConfiguration");

  263.         printError(err);

  264.         return -1;

  265.     }

  266. 

  267.     err = AudioDeviceAddPropertyListener(fDeviceID, 0, false, kAudioDevicePropertyStreamConfiguration, DeviceNotificationCallback, this);

  268.     if (err != noErr) {

  269.         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyStreamConfiguration");

  270.         printError(err);

  271.         return -1;

  272.     }

  273. 

  274.     return 0;

  275. }

  276. 

  277. 

  278. void JackCoreAudioAdapter::RemoveListeners()

  279. {

  280.     AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioHardwarePropertyDevices, DeviceNotificationCallback);

  281.     AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, DeviceNotificationCallback);

  282.     AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyDeviceIsRunning, DeviceNotificationCallback);

  283.     AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyStreamConfiguration, DeviceNotificationCallback);

  284.     AudioDeviceRemovePropertyListener(fDeviceID, 0, false, kAudioDevicePropertyStreamConfiguration, DeviceNotificationCallback);

  285. }

  286. 

  287. OSStatus JackCoreAudioAdapter::Render(void *inRefCon,

  288.                                         AudioUnitRenderActionFlags *ioActionFlags,

  289.                                         const AudioTimeStamp *inTimeStamp,

  290.                                         UInt32 inBusNumber,

  291.                                         UInt32 inNumberFrames,

  292.                                         AudioBufferList *ioData)

  293. {

  294.     JackCoreAudioAdapter* adapter = static_cast<JackCoreAudioAdapter*>(inRefCon);

  295.     AudioUnitRender(adapter->fAUHAL, ioActionFlags, inTimeStamp, 1, inNumberFrames, adapter->fInputData);

  296.     bool failure = false;

  297. 

  298.     jack_time_t time1, time2;

  299.     adapter->ResampleFactor(time1, time2);

  300. 

  301.     for (int i = 0; i < adapter->fCaptureChannels; i++) {

  302.         adapter->fCaptureRingBuffer[i]->SetRatio(time1, time2);

  303.         if (adapter->fCaptureRingBuffer[i]->WriteResample((float*)adapter->fInputData->mBuffers[i].mData, inNumberFrames) < inNumberFrames)

  304.             failure = true;

  305.     }

  306. 

  307.     for (int i = 0; i < adapter->fPlaybackChannels; i++) {

  308.         adapter->fPlaybackRingBuffer[i]->SetRatio(time2, time1);

  309.         if (adapter->fPlaybackRingBuffer[i]->ReadResample((float*)ioData->mBuffers[i].mData, inNumberFrames) < inNumberFrames)

  310.              failure = true;

  311.     }

  312. 

  313. #ifdef JACK_MONITOR

  314.     adapter->fTable.Write(time1, time2,  double(time1) / double(time2), double(time2) / double(time1),

  315.          adapter->fCaptureRingBuffer[0]->ReadSpace(),  adapter->fPlaybackRingBuffer[0]->WriteSpace());

  316. #endif

  317. 

  318.     // Reset all ringbuffers in case of failure

  319.     if (failure) {

  320.         jack_error("JackCoreAudioAdapter::Render ringbuffer failure... reset");

  321.         adapter->ResetRingBuffers();

  322.     }

  323. 

  324.     return noErr;

  325. }

  326. 

  327.  JackCoreAudioAdapter::JackCoreAudioAdapter(jack_nframes_t buffer_size, jack_nframes_t sample_rate, const JSList* params)

  328.                 :JackAudioAdapterInterface(buffer_size, sample_rate), fInputData(0), fCapturing(false), fPlaying(false), fState(false)

  329. {

  330. 

  331.     const JSList* node;

  332.     const jack_driver_param_t* param;

  333.    

  334.     char captureName[256];

  335.     char playbackName[256];

  336.         

  337.     fCaptureUID[0] = 0;

  338.     fPlaybackUID[0] = 0;

  339.     

  340.     // Default values

  341.     fCaptureChannels = 0;

  342.     fPlaybackChannels = 0;

  343.   

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

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

  346. 

  347.         switch (param->character) {

  348. 

  349.             case 'c' :

  350.                 fCaptureChannels = fPlaybackChannels = param->value.ui;

  351.                 break;

  352. 

  353.             case 'i':

  354.                 fCaptureChannels = param->value.ui;

  355.                 break;

  356. 

  357.             case 'o':

  358.                 fPlaybackChannels = param->value.ui;

  359.                 break;

  360. 

  361.             case 'C':

  362.                 fCapturing = true;

  363.                 strncpy(fCaptureUID, param->value.str, 256);

  364.                 break;

  365. 

  366.             case 'P':

  367.                 fPlaying = true;

  368.                 strncpy(fPlaybackUID, param->value.str, 256);

  369.                 break;

  370.                 

  371.             case 'd':

  372.                 strncpy(fCaptureUID, param->value.str, 256);

  373.                 strncpy(fPlaybackUID, param->value.str, 256);

  374.                 break;

  375. 

  376.             case 'D':

  377.                 fCapturing = fPlaying = true;

  378.                 break;

  379. 

  380.             case 'r':

  381.                 SetAdaptedSampleRate(param->value.ui);

  382.                 break;

  383. 

  384.             case 'p':

  385.                 SetAdaptedBufferSize(param->value.ui);

  386.                 break;

  387.                 

  388.             case 'l':

  389.                 DisplayDeviceNames();

  390.                 break;

  391.                 

  392.             case 'q':

  393.                 fQuality = param->value.ui;

  394.                 break;

  395.                 

  396.              case 'g':

  397.                 fRingbufferSize = param->value.ui;

  398.                 break;

  399.         }

  400.     }

  401.     

  402.     /* duplex is the default */

  403.     if (!fCapturing && !fPlaying) {

  404.         fCapturing = true;

  405.         fPlaying = true;

  406.     }

  407.      

  408.     int in_nChannels = 0;

  409.     int out_nChannels = 0;

  410.     

  411.     if (SetupDevices(fCaptureUID, fPlaybackUID, captureName, playbackName) < 0)

  412.         throw -1;

  413.   

  414.     if (SetupChannels(fCapturing, fPlaying, fCaptureChannels, fPlaybackChannels, in_nChannels, out_nChannels, true) < 0)

  415.         throw -1;

  416.  

  417.     if (SetupBufferSizeAndSampleRate(fAdaptedBufferSize, fAdaptedSampleRate) < 0)

  418.         throw -1;

  419. 

  420.     if (fCapturing && fCaptureChannels > 0)

  421.         if (SetupBuffers(fCaptureChannels) < 0)

  422.             throw -1;

  423.             

  424.     if (OpenAUHAL(fCapturing, fPlaying, fCaptureChannels, fPlaybackChannels, in_nChannels, out_nChannels, fAdaptedBufferSize, fAdaptedSampleRate, true) < 0)

  425.         throw -1;

  426.         

  427.     if (AddListeners() < 0)

  428.         throw -1;

  429. }

  430. 

  431. OSStatus JackCoreAudioAdapter::GetDefaultDevice(AudioDeviceID* id)

  432. {

  433.     OSStatus res;

  434.     UInt32 theSize = sizeof(UInt32);

  435.     AudioDeviceID inDefault;

  436.     AudioDeviceID outDefault;

  437. 

  438.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &theSize, &inDefault)) != noErr)

  439.         return res;

  440. 

  441.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &theSize, &outDefault)) != noErr)

  442.         return res;

  443. 

  444.     jack_log("GetDefaultDevice: input = %ld output = %ld", inDefault, outDefault);

  445. 

  446.     // Get the device only if default input and ouput are the same

  447.     if (inDefault == outDefault) {

  448.         *id = inDefault;

  449.         return noErr;

  450.     } else {

  451.         jack_error("Default input and output devices are not the same !!");

  452.         return kAudioHardwareBadDeviceError;

  453.     }

  454. }

  455. 

  456. OSStatus JackCoreAudioAdapter::GetTotalChannels(AudioDeviceID device, int& channelCount, bool isInput)

  457. {

  458.     OSStatus err = noErr;

  459.     UInt32	outSize;

  460.     Boolean	outWritable;

  461.     AudioBufferList* bufferList = 0;

  462. 

  463.     channelCount = 0;

  464.     err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize, &outWritable);

  465.     if (err == noErr) {

  466.         bufferList = (AudioBufferList*)malloc(outSize);

  467.         err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize, bufferList);

  468.         if (err == noErr) {

  469.             for (unsigned int i = 0; i < bufferList->mNumberBuffers; i++)

  470.                 channelCount += bufferList->mBuffers[i].mNumberChannels;

  471.         }

  472. 

  473.         if (bufferList)

  474.             free(bufferList);

  475.     }

  476. 

  477.     return err;

  478. }

  479. 

  480. OSStatus JackCoreAudioAdapter::GetDeviceIDFromUID(const char* UID, AudioDeviceID* id)

  481. {

  482.     UInt32 size = sizeof(AudioValueTranslation);

  483.     CFStringRef inIUD = CFStringCreateWithCString(NULL, UID, CFStringGetSystemEncoding());

  484.     AudioValueTranslation value = { &inIUD, sizeof(CFStringRef), id, sizeof(AudioDeviceID) };

  485. 

  486.     if (inIUD == NULL) {

  487.         return kAudioHardwareUnspecifiedError;

  488.     } else {

  489.         OSStatus res = AudioHardwareGetProperty(kAudioHardwarePropertyDeviceForUID, &size, &value);

  490.         CFRelease(inIUD);

  491.         jack_log("GetDeviceIDFromUID %s %ld", UID, *id);

  492.         return (*id == kAudioDeviceUnknown) ? kAudioHardwareBadDeviceError : res;

  493.     }

  494. }

  495. 

  496. OSStatus JackCoreAudioAdapter::GetDefaultInputDevice(AudioDeviceID* id)

  497. {

  498.     OSStatus res;

  499.     UInt32 theSize = sizeof(UInt32);

  500.     AudioDeviceID inDefault;

  501. 

  502.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &theSize, &inDefault)) != noErr)

  503.         return res;

  504. 

  505.     jack_log("GetDefaultInputDevice: input = %ld ", inDefault);

  506.     *id = inDefault;

  507.     return noErr;

  508. }

  509. 

  510. OSStatus JackCoreAudioAdapter::GetDefaultOutputDevice(AudioDeviceID* id)

  511. {

  512.     OSStatus res;

  513.     UInt32 theSize = sizeof(UInt32);

  514.     AudioDeviceID outDefault;

  515. 

  516.     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &theSize, &outDefault)) != noErr)

  517.         return res;

  518. 

  519.     jack_log("GetDefaultOutputDevice: output = %ld", outDefault);

  520.     *id = outDefault;

  521.     return noErr;

  522. }

  523. 

  524. OSStatus JackCoreAudioAdapter::GetDeviceNameFromID(AudioDeviceID id, char* name)

  525. {

  526.     UInt32 size = 256;

  527.     return AudioDeviceGetProperty(id, 0, false, kAudioDevicePropertyDeviceName, &size, name);

  528. }

  529. 

  530. // Setup

  531. int JackCoreAudioAdapter::SetupDevices(const char* capture_driver_uid,

  532.                                         const char* playback_driver_uid,

  533.                                         char* capture_driver_name,

  534.                                         char* playback_driver_name)

  535. {

  536.     capture_driver_name[0] = 0;

  537.     playback_driver_name[0] = 0;

  538. 

  539.     // Duplex

  540.     if (strcmp(capture_driver_uid, "") != 0 && strcmp(playback_driver_uid, "") != 0) {

  541.         jack_log("JackCoreAudioAdapter::Open duplex");

  542.         if (GetDeviceIDFromUID(playback_driver_uid, &fDeviceID) != noErr) {

  543.             if (GetDefaultDevice(&fDeviceID) != noErr) {

  544.                 jack_error("Cannot open default device");

  545.                 return -1;

  546.             }

  547.         }

  548.         if (GetDeviceNameFromID(fDeviceID, capture_driver_name) != noErr || GetDeviceNameFromID(fDeviceID, playback_driver_name) != noErr) {

  549.             jack_error("Cannot get device name from device ID");

  550.             return -1;

  551.         }

  552. 

  553.         // Capture only

  554.     } else if (strcmp(capture_driver_uid, "") != 0) {

  555.         jack_log("JackCoreAudioAdapter::Open capture only");

  556.         if (GetDeviceIDFromUID(capture_driver_uid, &fDeviceID) != noErr) {

  557.             if (GetDefaultInputDevice(&fDeviceID) != noErr) {

  558.                 jack_error("Cannot open default device");

  559.                 return -1;

  560.             }

  561.         }

  562.         if (GetDeviceNameFromID(fDeviceID, capture_driver_name) != noErr) {

  563.             jack_error("Cannot get device name from device ID");

  564.             return -1;

  565.         }

  566. 

  567.         // Playback only

  568.     } else if (strcmp(playback_driver_uid, "") != 0) {

  569.         jack_log("JackCoreAudioAdapter::Open playback only");

  570.         if (GetDeviceIDFromUID(playback_driver_uid, &fDeviceID) != noErr) {

  571.             if (GetDefaultOutputDevice(&fDeviceID) != noErr) {

  572.                 jack_error("Cannot open default device");

  573.                 return -1;

  574.             }

  575.         }

  576.         if (GetDeviceNameFromID(fDeviceID, playback_driver_name) != noErr) {

  577.             jack_error("Cannot get device name from device ID");

  578.             return -1;

  579.         }

  580. 

  581.         // Use default driver in duplex mode

  582.     } else {

  583.         jack_log("JackCoreAudioAdapter::Open default driver");

  584.         if (GetDefaultDevice(&fDeviceID) != noErr) {

  585.             jack_error("Cannot open default device");

  586.             return -1;

  587.         }

  588.         if (GetDeviceNameFromID(fDeviceID, capture_driver_name) != noErr || GetDeviceNameFromID(fDeviceID, playback_driver_name) != noErr) {

  589.             jack_error("Cannot get device name from device ID");

  590.             return -1;

  591.         }

  592.     }

  593. 

  594.     return 0;

  595. }

  596. 

  597. int JackCoreAudioAdapter::SetupChannels(bool capturing,

  598.                                         bool playing,

  599.                                         int& inchannels,

  600.                                         int& outchannels,

  601.                                         int& in_nChannels,

  602.                                         int& out_nChannels,

  603.                                         bool strict)

  604. {

  605.     OSStatus err = noErr;

  606. 

  607.     if (capturing) {

  608.         err = GetTotalChannels(fDeviceID, in_nChannels, true);

  609.         if (err != noErr) {

  610.             jack_error("Cannot get input channel number");

  611.             printError(err);

  612.             return -1;

  613.         } else {

  614.             jack_log("Max input channels : %d", in_nChannels);

  615.         }

  616.     }

  617. 

  618.     if (playing) {

  619.         err = GetTotalChannels(fDeviceID, out_nChannels, false);

  620.         if (err != noErr) {

  621.             jack_error("Cannot get output channel number");

  622.             printError(err);

  623.             return -1;

  624.         } else {

  625.             jack_log("Max output channels : %d", out_nChannels);

  626.         }

  627.     }

  628. 

  629.     if (inchannels > in_nChannels) {

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

  631.         if (strict)

  632.             return -1;

  633.     }

  634. 

  635.     if (outchannels > out_nChannels) {

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

  637.         if (strict)

  638.             return -1;

  639.     }

  640. 

  641.     if (inchannels == 0) {

  642.         jack_log("Setup max in channels = %ld", in_nChannels);

  643.         inchannels = in_nChannels;

  644.     }

  645. 

  646.     if (outchannels == 0) {

  647.         jack_log("Setup max out channels = %ld", out_nChannels);

  648.         outchannels = out_nChannels;

  649.     }

  650. 

  651.     return 0;

  652. }

  653. 

  654. int JackCoreAudioAdapter::SetupBufferSizeAndSampleRate(jack_nframes_t nframes, jack_nframes_t samplerate)

  655. {

  656.     OSStatus err = noErr;

  657.     UInt32 outSize;

  658.     Float64 sampleRate;

  659. 

  660.     // Setting buffer size

  661.     outSize = sizeof(UInt32);

  662.     err = AudioDeviceSetProperty(fDeviceID, NULL, 0, false, kAudioDevicePropertyBufferFrameSize, outSize, &nframes);

  663.     if (err != noErr) {

  664.         jack_error("Cannot set buffer size %ld", nframes);

  665.         printError(err);

  666.         return -1;

  667.     }

  668. 

  669.     // Get sample rate

  670.     outSize =  sizeof(Float64);

  671.     err = AudioDeviceGetProperty(fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);

  672.     if (err != noErr) {

  673.         jack_error("Cannot get current sample rate");

  674.         printError(err);

  675.         return -1;

  676.     }

  677. 

  678.     // If needed, set new sample rate

  679.     if (samplerate != (jack_nframes_t)sampleRate) {

  680.         sampleRate = (Float64)samplerate;

  681. 

  682.         // To get SR change notification

  683.         err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback, this);

  684.         if (err != noErr) {

  685.             jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyNominalSampleRate");

  686.             printError(err);

  687.             return -1;

  688.         }

  689.         err = AudioDeviceSetProperty(fDeviceID, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, outSize, &sampleRate);

  690.         if (err != noErr) {

  691.             jack_error("Cannot set sample rate = %ld", samplerate);

  692.             printError(err);

  693.             return -1;

  694.         }

  695. 

  696.         // Waiting for SR change notification

  697.         int count = 0;

  698.         while (!fState && count++ < 100) {

  699.             usleep(100000);

  700.             jack_log("Wait count = %ld", count);

  701.         }

  702. 

  703.         // Remove SR change notification

  704.         AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback);

  705.     }

  706. 

  707.     return 0;

  708. }

  709. 

  710. int JackCoreAudioAdapter::SetupBuffers(int inchannels)

  711. {

  712.     jack_log("JackCoreAudioAdapter::SetupBuffers: input = %ld", inchannels);

  713. 

  714.     // Prepare buffers

  715.     fInputData = (AudioBufferList*)malloc(sizeof(UInt32) + inchannels * sizeof(AudioBuffer));

  716.     if (fInputData == 0) {

  717.         jack_error("Cannot allocate memory for input buffers");

  718.         return -1;

  719.     }

  720.     fInputData->mNumberBuffers = inchannels;

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

  722.         fInputData->mBuffers[i].mNumberChannels = 1;

  723.         fInputData->mBuffers[i].mDataByteSize = fAdaptedBufferSize * sizeof(float);

  724.         fInputData->mBuffers[i].mData = malloc(fAdaptedBufferSize * sizeof(float));

  725.     }

  726.     return 0;

  727. }

  728. 

  729. void JackCoreAudioAdapter::DisposeBuffers()

  730. {

  731.     if (fInputData) {

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

  733.             free(fInputData->mBuffers[i].mData);

  734.         free(fInputData);

  735.         fInputData = 0;

  736.     }

  737. }

  738. 

  739. int JackCoreAudioAdapter::OpenAUHAL(bool capturing,

  740.                                     bool playing,

  741.                                     int inchannels,

  742.                                     int outchannels,

  743.                                     int in_nChannels,

  744.                                     int out_nChannels,

  745.                                     jack_nframes_t buffer_size,

  746.                                     jack_nframes_t samplerate,

  747.                                     bool strict)

  748. {

  749.     ComponentResult err1;

  750.     UInt32 enableIO;

  751.     AudioStreamBasicDescription srcFormat, dstFormat;

  752. 

  753.     jack_log("OpenAUHAL capturing = %ld playing = %ld inchannels = %ld outchannels = %ld in_nChannels = %ld out_nChannels = %ld ", capturing, playing, inchannels, outchannels, in_nChannels, out_nChannels);

  754. 

  755.     if (inchannels == 0 && outchannels == 0) {

  756.         jack_error("No input and output channels...");

  757.         return -1;

  758.     }

  759.          

  760.     // AUHAL

  761.     ComponentDescription cd = {kAudioUnitType_Output, kAudioUnitSubType_HALOutput, kAudioUnitManufacturer_Apple, 0, 0};

  762.     Component HALOutput = FindNextComponent(NULL, &cd);

  763. 

  764.     err1 = OpenAComponent(HALOutput, &fAUHAL);

  765.     if (err1 != noErr) {

  766.         jack_error("Error calling OpenAComponent");

  767.         printError(err1);

  768.         return -1;

  769.     }

  770. 

  771.     err1 = AudioUnitInitialize(fAUHAL);

  772.     if (err1 != noErr) {

  773.         jack_error("Cannot initialize AUHAL unit");

  774.         printError(err1);

  775.         return -1;

  776.     }

  777. 

  778.     // Start I/O

  779.     if (capturing && inchannels > 0) {

  780.         enableIO = 1;

  781.         jack_log("Setup AUHAL input on");

  782.     } else {

  783.         enableIO = 0;

  784.         jack_log("Setup AUHAL input off");

  785.     }

  786.     

  787.     err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &enableIO, sizeof(enableIO));

  788.     if (err1 != noErr) {

  789.         jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input");

  790.         printError(err1);

  791.         if (strict)

  792.             return -1;

  793.     }

  794. 

  795.     if (playing && outchannels > 0) {

  796.         enableIO = 1;

  797.         jack_log("Setup AUHAL output on");

  798.     } else {

  799.         enableIO = 0;

  800.         jack_log("Setup AUHAL output off");

  801.     }

  802.     

  803.     err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &enableIO, sizeof(enableIO));

  804.     if (err1 != noErr) {

  805.         jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_EnableIO,kAudioUnitScope_Output");

  806.         printError(err1);

  807.         if (strict)

  808.             return -1;

  809.     }

  810.     

  811.     AudioDeviceID currAudioDeviceID;

  812.     UInt32 size = sizeof(AudioDeviceID);

  813.     err1 = AudioUnitGetProperty(fAUHAL, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &currAudioDeviceID, &size);

  814.     if (err1 != noErr) {

  815.         jack_error("Error calling AudioUnitGetProperty - kAudioOutputUnitProperty_CurrentDevice");

  816.         printError(err1);

  817.         if (strict)

  818.             return -1;

  819.     } else {

  820.         jack_log("AudioUnitGetPropertyCurrentDevice = %d", currAudioDeviceID);

  821.     }

  822. 

  823.     // Setup up choosen device, in both input and output cases

  824.     err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &fDeviceID, sizeof(AudioDeviceID));

  825.     if (err1 != noErr) {

  826.         jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_CurrentDevice");

  827.         printError(err1);

  828.         if (strict)

  829.             return -1;

  830.     }

  831.     

  832.     err1 = AudioUnitGetProperty(fAUHAL, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &currAudioDeviceID, &size);

  833.     if (err1 != noErr) {

  834.         jack_error("Error calling AudioUnitGetProperty - kAudioOutputUnitProperty_CurrentDevice");

  835.         printError(err1);

  836.         if (strict)

  837.             return -1;

  838.     } else {

  839.         jack_log("AudioUnitGetPropertyCurrentDevice = %d", currAudioDeviceID);

  840.     }

  841. 

  842.     // Set buffer size

  843.     if (capturing && inchannels > 0) {

  844.         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 1, (UInt32*)&buffer_size, sizeof(UInt32));

  845.         if (err1 != noErr) {

  846.             jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_MaximumFramesPerSlice");

  847.             printError(err1);

  848.             if (strict)

  849.                 return -1;

  850.         }

  851.     }

  852. 

  853.     if (playing && outchannels > 0) {

  854.         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0, (UInt32*)&buffer_size, sizeof(UInt32));

  855.         if (err1 != noErr) {

  856.             jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_MaximumFramesPerSlice");

  857.             printError(err1);

  858.             if (strict)

  859.                 return -1;

  860.         }

  861.     }

  862. 

  863.     // Setup channel map

  864.     if (capturing && inchannels > 0 && inchannels < in_nChannels) {

  865.         SInt32 chanArr[in_nChannels];

  866.         for (int i = 0; i < in_nChannels; i++) {

  867.             chanArr[i] = -1;

  868.         }

  869.         for (int i = 0; i < inchannels; i++) {

  870.             chanArr[i] = i;

  871.         }

  872.         AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_ChannelMap , kAudioUnitScope_Input, 1, chanArr, sizeof(SInt32) * in_nChannels);

  873.         if (err1 != noErr) {

  874.             jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap 1");

  875.             printError(err1);

  876.         }

  877.     }

  878. 

  879.     if (playing && outchannels > 0 && outchannels < out_nChannels) {

  880.         SInt32 chanArr[out_nChannels];

  881.         for (int i = 0;	i < out_nChannels; i++) {

  882.             chanArr[i] = -1;

  883.         }

  884.         for (int i = 0; i < outchannels; i++) {

  885.             chanArr[i] = i;

  886.         }

  887.         err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_ChannelMap, kAudioUnitScope_Output, 0, chanArr, sizeof(SInt32) * out_nChannels);

  888.         if (err1 != noErr) {

  889.             jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap 0");

  890.             printError(err1);

  891.         }

  892.     }

  893. 

  894.     // Setup stream converters

  895.     jack_log("Setup AUHAL input stream converter SR = %ld", samplerate);

  896.     srcFormat.mSampleRate = samplerate;

  897.     srcFormat.mFormatID = kAudioFormatLinearPCM;

  898.     srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  899.     srcFormat.mBytesPerPacket = sizeof(float);

  900.     srcFormat.mFramesPerPacket = 1;

  901.     srcFormat.mBytesPerFrame = sizeof(float);

  902.     srcFormat.mChannelsPerFrame = outchannels;

  903.     srcFormat.mBitsPerChannel = 32;

  904. 

  905.     err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &srcFormat, sizeof(AudioStreamBasicDescription));

  906.     if (err1 != noErr) {

  907.         jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Input");

  908.         printError(err1);

  909.     }

  910. 

  911.     jack_log("Setup AUHAL output stream converter SR = %ld", samplerate);

  912.     dstFormat.mSampleRate = samplerate;

  913.     dstFormat.mFormatID = kAudioFormatLinearPCM;

  914.     dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  915.     dstFormat.mBytesPerPacket = sizeof(float);

  916.     dstFormat.mFramesPerPacket = 1;

  917.     dstFormat.mBytesPerFrame = sizeof(float);

  918.     dstFormat.mChannelsPerFrame = inchannels;

  919.     dstFormat.mBitsPerChannel = 32;

  920. 

  921.     err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &dstFormat, sizeof(AudioStreamBasicDescription));

  922.     if (err1 != noErr) {

  923.         jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output");

  924.         printError(err1);

  925.     }

  926. 

  927.     // Setup callbacks

  928.     if (inchannels > 0 && outchannels == 0) {

  929.         AURenderCallbackStruct output;

  930.         output.inputProc = Render;

  931.         output.inputProcRefCon = this;

  932.         err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &output, sizeof(output));

  933.         if (err1 != noErr) {

  934.             jack_error("Error calling  AudioUnitSetProperty - kAudioUnitProperty_SetRenderCallback 1");

  935.             printError(err1);

  936.             return -1;

  937.         }

  938.     } else {

  939.         AURenderCallbackStruct output;

  940.         output.inputProc = Render;

  941.         output.inputProcRefCon = this;

  942.         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &output, sizeof(output));

  943.         if (err1 != noErr) {

  944.             jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_SetRenderCallback 0");

  945.             printError(err1);

  946.             return -1;

  947.         }

  948.     }

  949. 

  950.     return 0;

  951. }

  952. 

  953. void JackCoreAudioAdapter::CloseAUHAL()

  954. {

  955.     AudioUnitUninitialize(fAUHAL);

  956.     CloseComponent(fAUHAL);

  957. }

  958. 

  959. int JackCoreAudioAdapter::Open()

  960. {

  961.     return (AudioOutputUnitStart(fAUHAL) != noErr)  ? -1 : 0;

  962. }

  963. 

  964. int JackCoreAudioAdapter::Close()

  965. {

  966. #ifdef JACK_MONITOR

  967.     fTable.Save();

  968. #endif

  969.     AudioOutputUnitStop(fAUHAL);

  970.     DisposeBuffers();

  971.     CloseAUHAL();

  972.     RemoveListeners();

  973.     return 0;

  974. }

  975. 

  976. int JackCoreAudioAdapter::SetSampleRate ( jack_nframes_t sample_rate ) {

  977.     JackAudioAdapterInterface::SetHostSampleRate ( sample_rate );

  978.     Close();

  979.     return Open();

  980. }

  981. 

  982. int JackCoreAudioAdapter::SetBufferSize ( jack_nframes_t buffer_size ) {

  983.     JackAudioAdapterInterface::SetHostBufferSize ( buffer_size );

  984.     Close();

  985.     return Open();

  986. }

  987. 

  988. } // namespace

  989. 

  990. #ifdef __cplusplus

  991. extern "C"

  992. {

  993. #endif

  994. 

  995.    SERVER_EXPORT jack_driver_desc_t* jack_get_descriptor()

  996.    {

  997.         jack_driver_desc_t *desc;

  998.         unsigned int i;

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

  1000. 

  1001.         strcpy(desc->name, "audioadapter");                            // size MUST be less then JACK_DRIVER_NAME_MAX + 1

  1002.         strcpy(desc->desc, "netjack audio <==> net backend adapter");  // size MUST be less then JACK_DRIVER_PARAM_DESC + 1

  1003.      

  1004.         desc->nparams = 12;

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

  1006. 

  1007.         i = 0;

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

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

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

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

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

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

  1014. 

  1015.         i++;

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

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

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

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

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

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

  1022. 

  1023.         i++;

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

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

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

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

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

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

  1030. 

  1031.         i++;

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

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

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

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

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

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

  1038. 

  1039.         i++;

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

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

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

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

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

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

  1046. 

  1047.         i++;

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

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

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

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

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

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

  1054. 

  1055.         i++;

  1056.         strcpy(desc->params[i].name, "periodsize");

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

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

  1059.         desc->params[i].value.ui = 512U;

  1060.         strcpy(desc->params[i].short_desc, "Period size");

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

  1062. 

  1063.         i++;

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

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

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

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

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

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

  1070. 

  1071.         i++;

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

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

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

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

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

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

  1078. 

  1079.         i++;

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

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

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

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

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

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

  1086.         

  1087.         i++;

  1088.         strcpy(desc->params[i].name, "quality");

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

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

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

  1092.         strcpy(desc->params[i].short_desc, "Resample algorithm quality (0 - 4)");

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

  1094.         

  1095.         i++;

  1096.         strcpy(desc->params[i].name, "ring-buffer");

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

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

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

  1100.         strcpy(desc->params[i].short_desc, "Resampling ringbuffer size in frames (default = 32768)");

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

  1102. 

  1103.         return desc;

  1104.     }

  1105. 

  1106. 

  1107. #ifdef __cplusplus

  1108. }

  1109. #endif