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

1096 lines
39KB
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.     

  297.     float* inputBuffer[adapter->fCaptureChannels];

  298.     float* outputBuffer[adapter->fPlaybackChannels];

  299.  

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

  301.         inputBuffer[i] = (float*)adapter->fInputData->mBuffers[i].mData;

  302.     }

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

  304.         outputBuffer[i] = (float*)ioData->mBuffers[i].mData;

  305.     }

  306.     

  307.     adapter->PushAndPull((float**)inputBuffer, (float**)outputBuffer, inNumberFrames);

  308.     return noErr;

  309. }

  310. 

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

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

  313. {

  314. 

  315.     const JSList* node;

  316.     const jack_driver_param_t* param;

  317.    

  318.     char captureName[256];

  319.     char playbackName[256];

  320.         

  321.     fCaptureUID[0] = 0;

  322.     fPlaybackUID[0] = 0;

  323.     

  324.     // Default values

  325.     fCaptureChannels = 0;

  326.     fPlaybackChannels = 0;

  327.   

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

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

  330. 

  331.         switch (param->character) {

  332. 

  333.             case 'c' :

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

  335.                 break;

  336. 

  337.             case 'i':

  338.                 fCaptureChannels = param->value.ui;

  339.                 break;

  340. 

  341.             case 'o':

  342.                 fPlaybackChannels = param->value.ui;

  343.                 break;

  344. 

  345.             case 'C':

  346.                 fCapturing = true;

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

  348.                 break;

  349. 

  350.             case 'P':

  351.                 fPlaying = true;

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

  353.                 break;

  354.                 

  355.             case 'd':

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

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

  358.                 break;

  359. 

  360.             case 'D':

  361.                 fCapturing = fPlaying = true;

  362.                 break;

  363. 

  364.             case 'r':

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

  366.                 break;

  367. 

  368.             case 'p':

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

  370.                 break;

  371.                 

  372.             case 'l':

  373.                 DisplayDeviceNames();

  374.                 break;

  375.                 

  376.             case 'q':

  377.                 fQuality = param->value.ui;

  378.                 break;

  379.                 

  380.             case 'g':

  381.                 fRingbufferCurSize = param->value.ui;

  382.                 fAdaptative = false;

  383.                 break;

  384.         }

  385.     }

  386.     

  387.     /* duplex is the default */

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

  389.         fCapturing = true;

  390.         fPlaying = true;

  391.     }

  392.      

  393.     int in_nChannels = 0;

  394.     int out_nChannels = 0;

  395.     

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

  397.         throw -1;

  398.   

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

  400.         throw -1;

  401.  

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

  403.         throw -1;

  404. 

  405.     if (fCapturing && fCaptureChannels > 0)

  406.         if (SetupBuffers(fCaptureChannels) < 0)

  407.             throw -1;

  408.             

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

  410.         throw -1;

  411.         

  412.     if (AddListeners() < 0)

  413.         throw -1;

  414. }

  415. 

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

  417. {

  418.     OSStatus res;

  419.     UInt32 theSize = sizeof(UInt32);

  420.     AudioDeviceID inDefault;

  421.     AudioDeviceID outDefault;

  422. 

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

  424.         return res;

  425. 

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

  427.         return res;

  428. 

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

  430. 

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

  432.     if (inDefault == outDefault) {

  433.         *id = inDefault;

  434.         return noErr;

  435.     } else {

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

  437.         return kAudioHardwareBadDeviceError;

  438.     }

  439. }

  440. 

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

  442. {

  443.     OSStatus err = noErr;

  444.     UInt32	outSize;

  445.     Boolean	outWritable;

  446.     AudioBufferList* bufferList = 0;

  447. 

  448.     channelCount = 0;

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

  450.     if (err == noErr) {

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

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

  453.         if (err == noErr) {

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

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

  456.         }

  457. 

  458.         if (bufferList)

  459.             free(bufferList);

  460.     }

  461. 

  462.     return err;

  463. }

  464. 

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

  466. {

  467.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  470. 

  471.     if (inIUD == NULL) {

  472.         return kAudioHardwareUnspecifiedError;

  473.     } else {

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

  475.         CFRelease(inIUD);

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

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

  478.     }

  479. }

  480. 

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

  482. {

  483.     OSStatus res;

  484.     UInt32 theSize = sizeof(UInt32);

  485.     AudioDeviceID inDefault;

  486. 

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

  488.         return res;

  489. 

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

  491.     *id = inDefault;

  492.     return noErr;

  493. }

  494. 

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

  496. {

  497.     OSStatus res;

  498.     UInt32 theSize = sizeof(UInt32);

  499.     AudioDeviceID outDefault;

  500. 

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

  502.         return res;

  503. 

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

  505.     *id = outDefault;

  506.     return noErr;

  507. }

  508. 

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

  510. {

  511.     UInt32 size = 256;

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

  513. }

  514. 

  515. // Setup

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

  517.                                         const char* playback_driver_uid,

  518.                                         char* capture_driver_name,

  519.                                         char* playback_driver_name)

  520. {

  521.     capture_driver_name[0] = 0;

  522.     playback_driver_name[0] = 0;

  523. 

  524.     // Duplex

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

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

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

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

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

  530.                 return -1;

  531.             }

  532.         }

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

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

  535.             return -1;

  536.         }

  537. 

  538.         // Capture only

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

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

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

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

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

  544.                 return -1;

  545.             }

  546.         }

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

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

  549.             return -1;

  550.         }

  551. 

  552.         // Playback only

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

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

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

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

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

  558.                 return -1;

  559.             }

  560.         }

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

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

  563.             return -1;

  564.         }

  565. 

  566.         // Use default driver in duplex mode

  567.     } else {

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

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

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

  571.             return -1;

  572.         }

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

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

  575.             return -1;

  576.         }

  577.     }

  578. 

  579.     return 0;

  580. }

  581. 

  582. int JackCoreAudioAdapter::SetupChannels(bool capturing,

  583.                                         bool playing,

  584.                                         int& inchannels,

  585.                                         int& outchannels,

  586.                                         int& in_nChannels,

  587.                                         int& out_nChannels,

  588.                                         bool strict)

  589. {

  590.     OSStatus err = noErr;

  591. 

  592.     if (capturing) {

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

  594.         if (err != noErr) {

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

  596.             printError(err);

  597.             return -1;

  598.         } else {

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

  600.         }

  601.     }

  602. 

  603.     if (playing) {

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

  605.         if (err != noErr) {

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

  607.             printError(err);

  608.             return -1;

  609.         } else {

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

  611.         }

  612.     }

  613. 

  614.     if (inchannels > in_nChannels) {

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

  616.         if (strict)

  617.             return -1;

  618.     }

  619. 

  620.     if (outchannels > out_nChannels) {

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

  622.         if (strict)

  623.             return -1;

  624.     }

  625. 

  626.     if (inchannels == 0) {

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

  628.         inchannels = in_nChannels;

  629.     }

  630. 

  631.     if (outchannels == 0) {

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

  633.         outchannels = out_nChannels;

  634.     }

  635. 

  636.     return 0;

  637. }

  638. 

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

  640. {

  641.     OSStatus err = noErr;

  642.     UInt32 outSize;

  643.     Float64 sampleRate;

  644. 

  645.     // Setting buffer size

  646.     outSize = sizeof(UInt32);

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

  648.     if (err != noErr) {

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

  650.         printError(err);

  651.         return -1;

  652.     }

  653. 

  654.     // Get sample rate

  655.     outSize =  sizeof(Float64);

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

  657.     if (err != noErr) {

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

  659.         printError(err);

  660.         return -1;

  661.     }

  662. 

  663.     // If needed, set new sample rate

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

  665.         sampleRate = (Float64)samplerate;

  666. 

  667.         // To get SR change notification

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

  669.         if (err != noErr) {

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

  671.             printError(err);

  672.             return -1;

  673.         }

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

  675.         if (err != noErr) {

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

  677.             printError(err);

  678.             return -1;

  679.         }

  680. 

  681.         // Waiting for SR change notification

  682.         int count = 0;

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

  684.             usleep(100000);

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

  686.         }

  687. 

  688.         // Remove SR change notification

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

  690.     }

  691. 

  692.     return 0;

  693. }

  694. 

  695. int JackCoreAudioAdapter::SetupBuffers(int inchannels)

  696. {

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

  698. 

  699.     // Prepare buffers

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

  701.     if (fInputData == 0) {

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

  703.         return -1;

  704.     }

  705.     fInputData->mNumberBuffers = inchannels;

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

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

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

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

  710.     }

  711.     return 0;

  712. }

  713. 

  714. void JackCoreAudioAdapter::DisposeBuffers()

  715. {

  716.     if (fInputData) {

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

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

  719.         free(fInputData);

  720.         fInputData = 0;

  721.     }

  722. }

  723. 

  724. int JackCoreAudioAdapter::OpenAUHAL(bool capturing,

  725.                                     bool playing,

  726.                                     int inchannels,

  727.                                     int outchannels,

  728.                                     int in_nChannels,

  729.                                     int out_nChannels,

  730.                                     jack_nframes_t buffer_size,

  731.                                     jack_nframes_t samplerate,

  732.                                     bool strict)

  733. {

  734.     ComponentResult err1;

  735.     UInt32 enableIO;

  736.     AudioStreamBasicDescription srcFormat, dstFormat;

  737. 

  738.     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);

  739. 

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

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

  742.         return -1;

  743.     }

  744.          

  745.     // AUHAL

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

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

  748. 

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

  750.     if (err1 != noErr) {

  751.         jack_error("Error calling OpenAComponent");

  752.         printError(err1);

  753.         return -1;

  754.     }

  755. 

  756.     err1 = AudioUnitInitialize(fAUHAL);

  757.     if (err1 != noErr) {

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

  759.         printError(err1);

  760.         return -1;

  761.     }

  762. 

  763.     // Start I/O

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

  765.         enableIO = 1;

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

  767.     } else {

  768.         enableIO = 0;

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

  770.     }

  771.     

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

  773.     if (err1 != noErr) {

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

  775.         printError(err1);

  776.         if (strict)

  777.             return -1;

  778.     }

  779. 

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

  781.         enableIO = 1;

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

  783.     } else {

  784.         enableIO = 0;

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

  786.     }

  787.     

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

  789.     if (err1 != noErr) {

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

  791.         printError(err1);

  792.         if (strict)

  793.             return -1;

  794.     }

  795.     

  796.     AudioDeviceID currAudioDeviceID;

  797.     UInt32 size = sizeof(AudioDeviceID);

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

  799.     if (err1 != noErr) {

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

  801.         printError(err1);

  802.         if (strict)

  803.             return -1;

  804.     } else {

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

  806.     }

  807. 

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

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

  810.     if (err1 != noErr) {

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

  812.         printError(err1);

  813.         if (strict)

  814.             return -1;

  815.     }

  816.     

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

  818.     if (err1 != noErr) {

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

  820.         printError(err1);

  821.         if (strict)

  822.             return -1;

  823.     } else {

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

  825.     }

  826. 

  827.     // Set buffer size

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

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

  830.         if (err1 != noErr) {

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

  832.             printError(err1);

  833.             if (strict)

  834.                 return -1;

  835.         }

  836.     }

  837. 

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

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

  840.         if (err1 != noErr) {

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

  842.             printError(err1);

  843.             if (strict)

  844.                 return -1;

  845.         }

  846.     }

  847. 

  848.     // Setup channel map

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

  850.         SInt32 chanArr[in_nChannels];

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

  852.             chanArr[i] = -1;

  853.         }

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

  855.             chanArr[i] = i;

  856.         }

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

  858.         if (err1 != noErr) {

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

  860.             printError(err1);

  861.         }

  862.     }

  863. 

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

  865.         SInt32 chanArr[out_nChannels];

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

  867.             chanArr[i] = -1;

  868.         }

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

  870.             chanArr[i] = i;

  871.         }

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

  873.         if (err1 != noErr) {

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

  875.             printError(err1);

  876.         }

  877.     }

  878. 

  879.     // Setup stream converters

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

  881.     srcFormat.mSampleRate = samplerate;

  882.     srcFormat.mFormatID = kAudioFormatLinearPCM;

  883.     srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  884.     srcFormat.mBytesPerPacket = sizeof(float);

  885.     srcFormat.mFramesPerPacket = 1;

  886.     srcFormat.mBytesPerFrame = sizeof(float);

  887.     srcFormat.mChannelsPerFrame = outchannels;

  888.     srcFormat.mBitsPerChannel = 32;

  889. 

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

  891.     if (err1 != noErr) {

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

  893.         printError(err1);

  894.     }

  895. 

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

  897.     dstFormat.mSampleRate = samplerate;

  898.     dstFormat.mFormatID = kAudioFormatLinearPCM;

  899.     dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  900.     dstFormat.mBytesPerPacket = sizeof(float);

  901.     dstFormat.mFramesPerPacket = 1;

  902.     dstFormat.mBytesPerFrame = sizeof(float);

  903.     dstFormat.mChannelsPerFrame = inchannels;

  904.     dstFormat.mBitsPerChannel = 32;

  905. 

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

  907.     if (err1 != noErr) {

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

  909.         printError(err1);

  910.     }

  911. 

  912.     // Setup callbacks

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

  914.         AURenderCallbackStruct output;

  915.         output.inputProc = Render;

  916.         output.inputProcRefCon = this;

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

  918.         if (err1 != noErr) {

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

  920.             printError(err1);

  921.             return -1;

  922.         }

  923.     } else {

  924.         AURenderCallbackStruct output;

  925.         output.inputProc = Render;

  926.         output.inputProcRefCon = this;

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

  928.         if (err1 != noErr) {

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

  930.             printError(err1);

  931.             return -1;

  932.         }

  933.     }

  934. 

  935.     return 0;

  936. }

  937. 

  938. void JackCoreAudioAdapter::CloseAUHAL()

  939. {

  940.     AudioUnitUninitialize(fAUHAL);

  941.     CloseComponent(fAUHAL);

  942. }

  943. 

  944. int JackCoreAudioAdapter::Open()

  945. {

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

  947. }

  948. 

  949. int JackCoreAudioAdapter::Close()

  950. {

  951. #ifdef JACK_MONITOR

  952.     fTable.Save(fHostBufferSize, fHostSampleRate, fAdaptedSampleRate, fAdaptedBufferSize);

  953. #endif

  954.     AudioOutputUnitStop(fAUHAL);

  955.     DisposeBuffers();

  956.     CloseAUHAL();

  957.     RemoveListeners();

  958.     return 0;

  959. }

  960. 

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

  962.     JackAudioAdapterInterface::SetHostSampleRate ( sample_rate );

  963.     Close();

  964.     return Open();

  965. }

  966. 

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

  968.     JackAudioAdapterInterface::SetHostBufferSize ( buffer_size );

  969.     Close();

  970.     return Open();

  971. }

  972. 

  973. } // namespace

  974. 

  975. #ifdef __cplusplus

  976. extern "C"

  977. {

  978. #endif

  979. 

  980.    SERVER_EXPORT jack_driver_desc_t* jack_get_descriptor()

  981.    {

  982.         jack_driver_desc_t *desc;

  983.         unsigned int i;

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

  985. 

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

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

  988.      

  989.         desc->nparams = 12;

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

  991. 

  992.         i = 0;

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

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

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

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

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

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

  999. 

  1000.         i++;

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

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

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

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

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

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

  1007. 

  1008.         i++;

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

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

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

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

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

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

  1015. 

  1016.         i++;

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

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

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

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

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

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

  1023. 

  1024.         i++;

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

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

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

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

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

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

  1031. 

  1032.         i++;

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

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

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

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

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

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

  1039. 

  1040.         i++;

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

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

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

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

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

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

  1047. 

  1048.         i++;

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

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

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

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

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

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

  1055. 

  1056.         i++;

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

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

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

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

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

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

  1063. 

  1064.         i++;

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

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

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

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

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

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

  1071.         

  1072.         i++;

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

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

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

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

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

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

  1079.         

  1080.         i++;

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

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

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

  1084.         desc->params[i].value.ui = 32768;

  1085.         strcpy(desc->params[i].short_desc, "Fixed ringbuffer size");

  1086.         strcpy(desc->params[i].long_desc, "Fixed ringbuffer size (if not set => automatic adaptative)");

  1087. 

  1088.         return desc;

  1089.     }

  1090. 

  1091. 

  1092. #ifdef __cplusplus

  1093. }

  1094. #endif