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

1610 lines
62KB
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. #include <CoreServices/CoreServices.h>

  25. 

  26. namespace Jack

  27. {

  28. 

  29. static void PrintStreamDesc(AudioStreamBasicDescription *inDesc)

  30. {

  31.     jack_log("- - - - - - - - - - - - - - - - - - - -");

  32.     jack_log("  Sample Rate:%f", inDesc->mSampleRate);

  33.     jack_log("  Format ID:%.*s", (int) sizeof(inDesc->mFormatID), (char*)&inDesc->mFormatID);

  34.     jack_log("  Format Flags:%lX", inDesc->mFormatFlags);

  35.     jack_log("  Bytes per Packet:%ld", inDesc->mBytesPerPacket);

  36.     jack_log("  Frames per Packet:%ld", inDesc->mFramesPerPacket);

  37.     jack_log("  Bytes per Frame:%ld", inDesc->mBytesPerFrame);

  38.     jack_log("  Channels per Frame:%ld", inDesc->mChannelsPerFrame);

  39.     jack_log("  Bits per Channel:%ld", inDesc->mBitsPerChannel);

  40.     jack_log("- - - - - - - - - - - - - - - - - - - -");

  41. }

  42. 

  43. static OSStatus DisplayDeviceNames()

  44. {

  45.     UInt32 size;

  46.     Boolean isWritable;

  47.     int i, deviceNum;

  48.     OSStatus err;

  49.     CFStringRef UIname;

  50. 

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

  52.     if (err != noErr)

  53.         return err;

  54. 

  55.     deviceNum = size / sizeof(AudioDeviceID);

  56.     AudioDeviceID devices[deviceNum];

  57. 

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

  59.     if (err != noErr)

  60.         return err;

  61. 

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

  63.         char device_name[256];

  64.         char internal_name[256];

  65. 

  66.         size = sizeof(CFStringRef);

  67.         UIname = NULL;

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

  69.         if (err == noErr) {

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

  71.         } else {

  72.             goto error;

  73.         }

  74. 

  75.         size = 256;

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

  77.         if (err != noErr)

  78.             return err;

  79. 

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

  81.     }

  82. 

  83.     return noErr;

  84. 

  85. error:

  86.     if (UIname != NULL)

  87.         CFRelease(UIname);

  88.     return err;

  89. }

  90. 

  91. static void printError(OSStatus err)

  92. {

  93.     switch (err) {

  94.         case kAudioHardwareNoError:

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

  96.             break;

  97.         case kAudioConverterErr_FormatNotSupported:

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

  99.             break;

  100.         case kAudioConverterErr_OperationNotSupported:

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

  102.             break;

  103.         case kAudioConverterErr_PropertyNotSupported:

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

  105.             break;

  106.         case kAudioConverterErr_InvalidInputSize:

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

  108.             break;

  109.         case kAudioConverterErr_InvalidOutputSize:

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

  111.             break;

  112.         case kAudioConverterErr_UnspecifiedError:

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

  114.             break;

  115.         case kAudioConverterErr_BadPropertySizeError:

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

  117.             break;

  118.         case kAudioConverterErr_RequiresPacketDescriptionsError:

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

  120.             break;

  121.         case kAudioConverterErr_InputSampleRateOutOfRange:

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

  123.             break;

  124.         case kAudioConverterErr_OutputSampleRateOutOfRange:

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

  126.             break;

  127.         case kAudioHardwareNotRunningError:

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

  129.             break;

  130.         case kAudioHardwareUnknownPropertyError:

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

  132.             break;

  133.         case kAudioHardwareIllegalOperationError:

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

  135.             break;

  136.         case kAudioHardwareBadDeviceError:

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

  138.             break;

  139.         case kAudioHardwareBadStreamError:

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

  141.             break;

  142.         case kAudioDeviceUnsupportedFormatError:

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

  144.             break;

  145.         case kAudioDevicePermissionsError:

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

  147.             break;

  148.         case kAudioHardwareBadObjectError:

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

  150.             break;

  151.         case kAudioHardwareUnsupportedOperationError:

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

  153.             break;

  154.         default:

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

  156.             break;

  157.     }

  158. }

  159. 

  160. OSStatus JackCoreAudioAdapter::SRNotificationCallback(AudioDeviceID inDevice,

  161.                                                         UInt32 inChannel,

  162.                                                         Boolean	isInput,

  163.                                                         AudioDevicePropertyID inPropertyID,

  164.                                                         void* inClientData)

  165. {

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

  167. 

  168.     switch (inPropertyID) {

  169. 

  170.         case kAudioDevicePropertyNominalSampleRate: {

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

  172.             driver->fState = true;

  173.             break;

  174.         }

  175.     }

  176. 

  177.     return noErr;

  178. }

  179. 

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

  181. OSStatus JackCoreAudioAdapter::DeviceNotificationCallback(AudioDeviceID inDevice,

  182.         UInt32 inChannel,

  183.         Boolean	isInput,

  184.         AudioDevicePropertyID inPropertyID,

  185.         void* inClientData)

  186. {

  187.         

  188.     switch (inPropertyID) {

  189.         

  190.         case kAudioDeviceProcessorOverload: {

  191.             jack_error("JackCoreAudioAdapter::DeviceNotificationCallback kAudioDeviceProcessorOverload");

  192.             break;

  193. 		}

  194. 

  195.         case kAudioDevicePropertyStreamConfiguration: {

  196.             jack_error("Cannot handle kAudioDevicePropertyStreamConfiguration");

  197.             return kAudioHardwareUnsupportedOperationError;

  198.         }

  199.             

  200.         case kAudioDevicePropertyNominalSampleRate: {

  201.             jack_error("Cannot handle kAudioDevicePropertyNominalSampleRate");

  202.             return kAudioHardwareUnsupportedOperationError;

  203.         }

  204.             

  205.     }

  206.     return noErr;

  207. }

  208. 

  209. int JackCoreAudioAdapter::AddListeners()

  210. {

  211.     OSStatus err = noErr;

  212. 

  213.     // Add listeners

  214.     err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDeviceProcessorOverload, DeviceNotificationCallback, this);

  215.     if (err != noErr) {

  216.         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDeviceProcessorOverload");

  217.         printError(err);

  218.         return -1;

  219.     }

  220.     

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

  222.     if (err != noErr) {

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

  224.         printError(err);

  225.         return -1;

  226.     }

  227. 

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

  229.     if (err != noErr) {

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

  231.         printError(err);

  232.         return -1;

  233.     }

  234. 

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

  236.     if (err != noErr) {

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

  238.         printError(err);

  239.         return -1;

  240.     }

  241. 

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

  243.     if (err != noErr) {

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

  245.         printError(err);

  246.         return -1;

  247.     }

  248. 

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

  250.     if (err != noErr) {

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

  252.         printError(err);

  253.         return -1;

  254.     }

  255. 

  256.     return 0;

  257. }

  258. 

  259. void JackCoreAudioAdapter::RemoveListeners()

  260. {

  261.     AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDeviceProcessorOverload, DeviceNotificationCallback);

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

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

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

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

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

  267. }

  268. 

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

  270.                                         AudioUnitRenderActionFlags *ioActionFlags,

  271.                                         const AudioTimeStamp *inTimeStamp,

  272.                                         UInt32 inBusNumber,

  273.                                         UInt32 inNumberFrames,

  274.                                         AudioBufferList *ioData)

  275. {

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

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

  278.     

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

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

  281.  

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

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

  284.     }

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

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

  287.     }

  288.     

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

  290.     return noErr;

  291. }

  292. 

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

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

  295. {

  296.     const JSList* node;

  297.     const jack_driver_param_t* param;

  298.     int in_nChannels = 0;

  299.     int out_nChannels = 0;

  300.     char captureName[256];

  301.     char playbackName[256];

  302.     fCaptureUID[0] = 0;

  303.     fPlaybackUID[0] = 0;

  304.     fClockDriftCompensate = false;

  305.     

  306.     // Default values

  307.     fCaptureChannels = -1;

  308.     fPlaybackChannels = -1;

  309.     

  310.     SInt32 major;

  311.     SInt32 minor;

  312.     Gestalt(gestaltSystemVersionMajor, &major);

  313.     Gestalt(gestaltSystemVersionMinor, &minor);

  314.     

  315.     // Starting with 10.6 systems, the HAL notification thread is created internally

  316.     if (major == 10 && minor >= 6) {

  317.         CFRunLoopRef theRunLoop = NULL;

  318.         AudioObjectPropertyAddress theAddress = { kAudioHardwarePropertyRunLoop, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };

  319.         OSStatus theError = AudioObjectSetPropertyData (kAudioObjectSystemObject, &theAddress, 0, NULL, sizeof(CFRunLoopRef), &theRunLoop);

  320.         if (theError != noErr) {

  321.             jack_error("JackCoreAudioAdapter::Open kAudioHardwarePropertyRunLoop error");

  322.         }

  323.     }

  324.   

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

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

  327. 

  328.         switch (param->character) {

  329. 

  330.             case 'c' :

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

  332.                 break;

  333. 

  334.             case 'i':

  335.                 fCaptureChannels = param->value.ui;

  336.                 break;

  337. 

  338.             case 'o':

  339.                 fPlaybackChannels = param->value.ui;

  340.                 break;

  341. 

  342.             case 'C':

  343.                 fCapturing = true;

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

  345.                 break;

  346. 

  347.             case 'P':

  348.                 fPlaying = true;

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

  350.                 break;

  351.                 

  352.             case 'd':

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

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

  355.                 break;

  356. 

  357.             case 'D':

  358.                 fCapturing = fPlaying = true;

  359.                 break;

  360. 

  361.             case 'r':

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

  363.                 break;

  364. 

  365.             case 'p':

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

  367.                 break;

  368.                 

  369.             case 'l':

  370.                 DisplayDeviceNames();

  371.                 break;

  372.                 

  373.             case 'q':

  374.                 fQuality = param->value.ui;

  375.                 break;

  376.                 

  377.             case 'g':

  378.                 fRingbufferCurSize = param->value.ui;

  379.                 fAdaptative = false;

  380.                 break;

  381.                 

  382.             case 's':

  383.                 fClockDriftCompensate = true;

  384.                 break;

  385.         }

  386.     }

  387.     

  388.     /* duplex is the default */

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

  390.         fCapturing = true;

  391.         fPlaying = true;

  392.     }

  393.     

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

  395.         throw -1;

  396.   

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

  398.         throw -1;

  399.     

  400.     if (SetupBufferSize(fAdaptedBufferSize) < 0)

  401.          throw -1;

  402.  

  403.     if (SetupSampleRate(fAdaptedSampleRate) < 0)

  404.         throw -1;

  405.            

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

  407.         throw -1;

  408.          

  409.     if (fCapturing && fCaptureChannels > 0)

  410.         if (SetupBuffers(fCaptureChannels) < 0)

  411.             throw -1;

  412.        

  413.     if (AddListeners() < 0)

  414.         throw -1;

  415. }

  416. 

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

  418. {

  419.     OSStatus res;

  420.     UInt32 theSize = sizeof(UInt32);

  421.     AudioDeviceID inDefault;

  422.     AudioDeviceID outDefault;

  423. 

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

  425.         return res;

  426. 

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

  428.         return res;

  429. 

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

  431. 

  432.     // Get the device only if default input and output are the same

  433.     if (inDefault == outDefault) {

  434.         *id = inDefault;

  435.         return noErr;

  436.     } else {

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

  438.         return kAudioHardwareBadDeviceError;

  439.     }

  440. }

  441. 

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

  443. {

  444.     OSStatus err = noErr;

  445.     UInt32	outSize;

  446.     Boolean	outWritable;

  447.     AudioBufferList* bufferList = 0;

  448. 

  449.     channelCount = 0;

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

  451.     if (err == noErr) {

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

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

  454.         if (err == noErr) {

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

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

  457.         }

  458. 

  459.         if (bufferList)

  460.             free(bufferList);

  461.     }

  462. 

  463.     return err;

  464. }

  465. 

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

  467. {

  468.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  471. 

  472.     if (inIUD == NULL) {

  473.         return kAudioHardwareUnspecifiedError;

  474.     } else {

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

  476.         CFRelease(inIUD);

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

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

  479.     }

  480. }

  481. 

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

  483. {

  484.     OSStatus res;

  485.     UInt32 theSize = sizeof(UInt32);

  486.     AudioDeviceID inDefault;

  487. 

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

  489.         return res;

  490. 

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

  492.     *id = inDefault;

  493.     return noErr;

  494. }

  495. 

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

  497. {

  498.     OSStatus res;

  499.     UInt32 theSize = sizeof(UInt32);

  500.     AudioDeviceID outDefault;

  501. 

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

  503.         return res;

  504. 

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

  506.     *id = outDefault;

  507.     return noErr;

  508. }

  509. 

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

  511. {

  512.     UInt32 size = 256;

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

  514. }

  515. 

  516. // Setup

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

  518.                                         const char* playback_driver_uid,

  519.                                         char* capture_driver_name,

  520.                                         char* playback_driver_name,

  521.                                         jack_nframes_t samplerate)

  522. {

  523.     capture_driver_name[0] = 0;

  524.     playback_driver_name[0] = 0;

  525. 

  526.     // Duplex

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

  528.     

  529.         // Same device for capture and playback...

  530.         if (strcmp(capture_driver_uid, playback_driver_uid) == 0)  {

  531.             

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

  533.                 jack_log("Will take default in/out");

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

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

  536.                     return -1;

  537.                 }

  538.             }

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

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

  541.                 return -1;

  542.             }

  543.             

  544.         } else {

  545.         

  546.             // Creates aggregate device

  547.             AudioDeviceID captureID, playbackID;

  548.             

  549.             if (GetDeviceIDFromUID(capture_driver_uid, &captureID) != noErr) {

  550.                 jack_log("Will take default input");

  551.                 if (GetDefaultInputDevice(&captureID) != noErr) {

  552.                     jack_error("Cannot open default input device");

  553.                     return -1;

  554.                 }

  555.             }

  556.             

  557.             if (GetDeviceIDFromUID(playback_driver_uid, &playbackID) != noErr) {

  558.                 jack_log("Will take default output");

  559.                 if (GetDefaultOutputDevice(&playbackID) != noErr) {

  560.                     jack_error("Cannot open default output device");

  561.                     return -1;

  562.                 }

  563.             }

  564.             

  565.             if (CreateAggregateDevice(captureID, playbackID, samplerate, &fDeviceID) != noErr)

  566.                 return -1;

  567.         }

  568. 

  569.     // Capture only

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

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

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

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

  574.                 jack_error("Cannot open default input device");

  575.                 return -1;

  576.             }

  577.         }

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

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

  580.             return -1;

  581.         }

  582. 

  583.     // Playback only

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

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

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

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

  588.                 jack_error("Cannot open default output device");

  589.                 return -1;

  590.             }

  591.         }

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

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

  594.             return -1;

  595.         }

  596. 

  597.     // Use default driver in duplex mode

  598.     } else {

  599.         jack_log("JackCoreAudioDriver::Open default driver");

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

  601.             jack_error("Cannot open default device in duplex mode, so aggregate default input and default output");

  602.             

  603.             // Creates aggregate device

  604.             AudioDeviceID captureID, playbackID;

  605.             

  606.             if (GetDeviceIDFromUID(capture_driver_uid, &captureID) != noErr) {

  607.                 jack_log("Will take default input");

  608.                 if (GetDefaultInputDevice(&captureID) != noErr) {

  609.                     jack_error("Cannot open default input device");

  610.                     return -1;

  611.                 }

  612.             }

  613.             

  614.             if (GetDeviceIDFromUID(playback_driver_uid, &playbackID) != noErr) {

  615.                 jack_log("Will take default output");

  616.                 if (GetDefaultOutputDevice(&playbackID) != noErr) {

  617.                     jack_error("Cannot open default output device");

  618.                     return -1;

  619.                 }

  620.             }

  621.             

  622.             if (CreateAggregateDevice(captureID, playbackID, samplerate, &fDeviceID) != noErr)

  623.                 return -1;

  624.         }

  625.     }

  626. 

  627.     return 0;

  628. }

  629. 

  630. int JackCoreAudioAdapter::SetupChannels(bool capturing,

  631.                                         bool playing,

  632.                                         int& inchannels,

  633.                                         int& outchannels,

  634.                                         int& in_nChannels,

  635.                                         int& out_nChannels,

  636.                                         bool strict)

  637. {

  638.     OSStatus err = noErr;

  639. 

  640.     if (capturing) {

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

  642.         if (err != noErr) {

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

  644.             printError(err);

  645.             return -1;

  646.         } else {

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

  648.         }

  649.     }

  650. 

  651.     if (playing) {

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

  653.         if (err != noErr) {

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

  655.             printError(err);

  656.             return -1;

  657.         } else {

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

  659.         }

  660.     }

  661. 

  662.     if (inchannels > in_nChannels) {

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

  664.         if (strict)

  665.             return -1;

  666.     }

  667. 

  668.     if (outchannels > out_nChannels) {

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

  670.         if (strict)

  671.             return -1;

  672.     }

  673. 

  674.     if (inchannels == -1) {

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

  676.         inchannels = in_nChannels;

  677.     }

  678. 

  679.     if (outchannels == -1) {

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

  681.         outchannels = out_nChannels;

  682.     }

  683.  

  684.     return 0;

  685. }

  686. 

  687. int JackCoreAudioAdapter::SetupBufferSize(jack_nframes_t buffer_size)

  688. {

  689.     // Setting buffer size

  690.     UInt32 outSize = sizeof(UInt32);

  691.     OSStatus err = AudioDeviceSetProperty(fDeviceID, NULL, 0, false, kAudioDevicePropertyBufferFrameSize, outSize, &buffer_size);

  692.     if (err != noErr) {

  693.         jack_error("Cannot set buffer size %ld", buffer_size);

  694.         printError(err);

  695.         return -1;

  696.     }

  697.     

  698.     return 0;

  699. }

  700. 

  701. int JackCoreAudioAdapter::SetupSampleRate(jack_nframes_t samplerate)

  702. {

  703.     return SetupSampleRateAux(fDeviceID, samplerate);

  704. }

  705. 

  706. int JackCoreAudioAdapter::SetupSampleRateAux(AudioDeviceID inDevice, jack_nframes_t samplerate)

  707. {

  708.     OSStatus err = noErr;

  709.     UInt32 outSize;

  710.     Float64 sampleRate;

  711.     

  712.     // Get sample rate

  713.     outSize =  sizeof(Float64);

  714.     err = AudioDeviceGetProperty(inDevice, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);

  715.     if (err != noErr) {

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

  717.         printError(err);

  718.         return -1;

  719.     }

  720.     

  721.     // If needed, set new sample rate

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

  723.         sampleRate = (Float64)samplerate;

  724.         

  725.         // To get SR change notification

  726.         err = AudioDeviceAddPropertyListener(inDevice, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback, this);

  727.         if (err != noErr) {

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

  729.             printError(err);

  730.             return -1;

  731.         }

  732.         err = AudioDeviceSetProperty(inDevice, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, outSize, &sampleRate);

  733.         if (err != noErr) {

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

  735.             printError(err);

  736.             return -1;

  737.         }

  738.         

  739.         // Waiting for SR change notification

  740.         int count = 0;

  741.         while (!fState && count++ < WAIT_COUNTER) {

  742.             usleep(100000);

  743.             jack_log("Wait count = %d", count);

  744.         }

  745.         

  746.         // Remove SR change notification

  747.         AudioDeviceRemovePropertyListener(inDevice, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback);

  748.     }

  749.     

  750.     return 0;

  751. }

  752. 

  753. int JackCoreAudioAdapter::SetupBuffers(int inchannels)

  754. {

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

  756. 

  757.     // Prepare buffers

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

  759.     fInputData->mNumberBuffers = inchannels;

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

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

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

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

  764.     }

  765.     return 0;

  766. }

  767. 

  768. void JackCoreAudioAdapter::DisposeBuffers()

  769. {

  770.     if (fInputData) {

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

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

  773.         free(fInputData);

  774.         fInputData = 0;

  775.     }

  776. }

  777. 

  778. int JackCoreAudioAdapter::OpenAUHAL(bool capturing,

  779.                                    bool playing,

  780.                                    int inchannels,

  781.                                    int outchannels,

  782.                                    int in_nChannels,

  783.                                    int out_nChannels,

  784.                                    jack_nframes_t buffer_size,

  785.                                    jack_nframes_t samplerate)

  786. {

  787.     ComponentResult err1;

  788.     UInt32 enableIO;

  789.     AudioStreamBasicDescription srcFormat, dstFormat;

  790.     AudioDeviceID currAudioDeviceID;

  791.     UInt32 size;

  792. 

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

  794. 

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

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

  797.         return -1;

  798.     }

  799.          

  800.     // AUHAL

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

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

  803. 

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

  805.     if (err1 != noErr) {

  806.         jack_error("Error calling OpenAComponent");

  807.         printError(err1);

  808.         goto error;

  809.     }

  810. 

  811.     err1 = AudioUnitInitialize(fAUHAL);

  812.     if (err1 != noErr) {

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

  814.         printError(err1);

  815.         goto error;

  816.     }

  817. 

  818.     // Start I/O

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

  820.         enableIO = 1;

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

  822.     } else {

  823.         enableIO = 0;

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

  825.     }

  826.     

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

  828.     if (err1 != noErr) {

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

  830.         printError(err1);

  831.         goto error;

  832.     }

  833. 

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

  835.         enableIO = 1;

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

  837.     } else {

  838.         enableIO = 0;

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

  840.     }

  841.     

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

  843.     if (err1 != noErr) {

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

  845.         printError(err1);

  846.         goto error;

  847.     }

  848.     

  849.     size = sizeof(AudioDeviceID);

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

  851.     if (err1 != noErr) {

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

  853.         printError(err1);

  854.         goto error;

  855.     } else {

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

  857.     }

  858. 

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

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

  861.     if (err1 != noErr) {

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

  863.         printError(err1);

  864.         goto error;

  865.     }

  866.   

  867.     // Set buffer size

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

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

  870.         if (err1 != noErr) {

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

  872.             printError(err1);

  873.             goto error;

  874.         }

  875.     }

  876. 

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

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

  879.         if (err1 != noErr) {

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

  881.             printError(err1);

  882.             goto error;

  883.         }

  884.     }

  885. 

  886.     // Setup channel map

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

  888.         SInt32 chanArr[in_nChannels];

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

  890.             chanArr[i] = -1;

  891.         }

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

  893.             chanArr[i] = i;

  894.         }

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

  896.         if (err1 != noErr) {

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

  898.             printError(err1);

  899.             goto error;

  900.         }

  901.     }

  902. 

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

  904.         SInt32 chanArr[out_nChannels];

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

  906.             chanArr[i] = -1;

  907.         }

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

  909.             chanArr[i] = i;

  910.         }

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

  912.         if (err1 != noErr) {

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

  914.             printError(err1);

  915.             goto error;

  916.         }

  917.     }

  918. 

  919.     // Setup stream converters

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

  921.     

  922.         size = sizeof(AudioStreamBasicDescription);

  923.         err1 = AudioUnitGetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, &srcFormat, &size);

  924.         if (err1 != noErr) {

  925.             jack_error("Error calling AudioUnitGetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Input");

  926.             printError(err1);

  927.             goto error;

  928.         }

  929.         PrintStreamDesc(&srcFormat);

  930.               

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

  932.         srcFormat.mSampleRate = samplerate;

  933.         srcFormat.mFormatID = kAudioFormatLinearPCM;

  934.         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  935.         srcFormat.mBytesPerPacket = sizeof(float);

  936.         srcFormat.mFramesPerPacket = 1;

  937.         srcFormat.mBytesPerFrame = sizeof(float);

  938.         srcFormat.mChannelsPerFrame = inchannels;

  939.         srcFormat.mBitsPerChannel = 32;

  940.         PrintStreamDesc(&srcFormat);

  941.       

  942.         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &srcFormat, sizeof(AudioStreamBasicDescription));

  943.         

  944.         if (err1 != noErr) {

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

  946.             printError(err1);

  947.             goto error;

  948.         }

  949.     }

  950. 

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

  952.     

  953.         size = sizeof(AudioStreamBasicDescription);

  954.         err1 = AudioUnitGetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 1, &dstFormat, &size);

  955.         if (err1 != noErr) {

  956.             jack_error("Error calling AudioUnitGetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output");

  957.             printError(err1);

  958.             goto error;

  959.         }

  960.         PrintStreamDesc(&dstFormat);

  961.          

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

  963.         dstFormat.mSampleRate = samplerate;

  964.         dstFormat.mFormatID = kAudioFormatLinearPCM;

  965.         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  966.         dstFormat.mBytesPerPacket = sizeof(float);

  967.         dstFormat.mFramesPerPacket = 1;

  968.         dstFormat.mBytesPerFrame = sizeof(float);

  969.         dstFormat.mChannelsPerFrame = outchannels;

  970.         dstFormat.mBitsPerChannel = 32;

  971.         PrintStreamDesc(&dstFormat);

  972.        

  973.         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &dstFormat, sizeof(AudioStreamBasicDescription));

  974.         

  975.         if (err1 != noErr) {

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

  977.             printError(err1);

  978.             goto error;

  979.         }

  980.     }

  981. 

  982.     // Setup callbacks

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

  984.         AURenderCallbackStruct output;

  985.         output.inputProc = Render;

  986.         output.inputProcRefCon = this;

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

  988.         if (err1 != noErr) {

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

  990.             printError(err1);

  991.             goto error;

  992.         }

  993.     } else {

  994.         AURenderCallbackStruct output;

  995.         output.inputProc = Render;

  996.         output.inputProcRefCon = this;

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

  998.         if (err1 != noErr) {

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

  1000.             printError(err1);

  1001.             goto error;

  1002.         }

  1003.     }

  1004. 

  1005.     return 0;

  1006.     

  1007. error:

  1008.     CloseAUHAL();

  1009.     return -1;

  1010. }

  1011. 

  1012. OSStatus JackCoreAudioAdapter::DestroyAggregateDevice() 

  1013. {

  1014.     OSStatus osErr = noErr;

  1015.     AudioObjectPropertyAddress pluginAOPA;

  1016.     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;

  1017.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1018.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1019.     UInt32 outDataSize;

  1020.   

  1021.     osErr = AudioObjectGetPropertyDataSize(fPluginID, &pluginAOPA, 0, NULL, &outDataSize);

  1022.     if (osErr != noErr) {

  1023.         jack_error("JackCoreAudioDriver::DestroyAggregateDevice : AudioObjectGetPropertyDataSize error");

  1024.         printError(osErr);

  1025.         return osErr;

  1026.     }

  1027.         

  1028.     osErr = AudioObjectGetPropertyData(fPluginID, &pluginAOPA, 0, NULL, &outDataSize, &fDeviceID);

  1029.     if (osErr != noErr) {

  1030.         jack_error("JackCoreAudioDriver::DestroyAggregateDevice : AudioObjectGetPropertyData error");

  1031.         printError(osErr);

  1032.         return osErr;

  1033.     }

  1034.     

  1035.     return noErr;

  1036. }

  1037. 

  1038. static CFStringRef GetDeviceName(AudioDeviceID id)

  1039. {

  1040.     UInt32 size = sizeof(CFStringRef);

  1041.     CFStringRef UIname;

  1042.     OSStatus err = AudioDeviceGetProperty(id, 0, false, kAudioDevicePropertyDeviceUID, &size, &UIname);

  1043.     return (err == noErr) ? UIname : NULL;

  1044. }

  1045. 

  1046. OSStatus JackCoreAudioAdapter::CreateAggregateDevice(AudioDeviceID captureDeviceID, AudioDeviceID playbackDeviceID, jack_nframes_t samplerate, AudioDeviceID* outAggregateDevice) 

  1047. {

  1048.     OSStatus err = noErr;

  1049.     AudioObjectID sub_device[32];

  1050.     UInt32 outSize = sizeof(sub_device);

  1051.     

  1052.     err = AudioDeviceGetProperty(captureDeviceID, 0, kAudioDeviceSectionGlobal, kAudioAggregateDevicePropertyActiveSubDeviceList, &outSize, sub_device);

  1053.     vector<AudioDeviceID> captureDeviceIDArray;

  1054.     

  1055.     if (err != noErr) {

  1056.         jack_log("Input device does not have subdevices");

  1057.         captureDeviceIDArray.push_back(captureDeviceID);

  1058.     } else {

  1059.         int num_devices = outSize / sizeof(AudioObjectID);

  1060.         jack_log("Input device has %d subdevices", num_devices);

  1061.         for (int i = 0; i < num_devices; i++) {

  1062.             captureDeviceIDArray.push_back(sub_device[i]);

  1063.         }

  1064.     }

  1065.     

  1066.     err = AudioDeviceGetProperty(playbackDeviceID, 0, kAudioDeviceSectionGlobal, kAudioAggregateDevicePropertyActiveSubDeviceList, &outSize, sub_device);    

  1067.     vector<AudioDeviceID> playbackDeviceIDArray;

  1068.     

  1069.     if (err != noErr) {

  1070.         jack_log("Output device does not have subdevices");

  1071.         playbackDeviceIDArray.push_back(playbackDeviceID);

  1072.     } else {

  1073.         int num_devices = outSize / sizeof(AudioObjectID);

  1074.         jack_log("Output device has %d subdevices", num_devices);

  1075.         for (int i = 0; i < num_devices; i++) {

  1076.             playbackDeviceIDArray.push_back(sub_device[i]);

  1077.         }

  1078.     }

  1079.     

  1080.     return CreateAggregateDeviceAux(captureDeviceIDArray, playbackDeviceIDArray, samplerate, outAggregateDevice);

  1081. }

  1082.     

  1083. OSStatus JackCoreAudioAdapter::CreateAggregateDeviceAux(vector<AudioDeviceID> captureDeviceID, vector<AudioDeviceID> playbackDeviceID, jack_nframes_t samplerate, AudioDeviceID* outAggregateDevice) 

  1084. {

  1085.     OSStatus osErr = noErr;

  1086.     UInt32 outSize;

  1087.     Boolean outWritable;

  1088.     

  1089.     // Prepare sub-devices for clock drift compensation

  1090.     // Workaround for bug in the HAL : until 10.6.2

  1091.     AudioObjectPropertyAddress theAddressOwned = { kAudioObjectPropertyOwnedObjects, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };

  1092.     AudioObjectPropertyAddress theAddressDrift = { kAudioSubDevicePropertyDriftCompensation, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };

  1093.     UInt32 theQualifierDataSize = sizeof(AudioObjectID);

  1094.     AudioClassID inClass = kAudioSubDeviceClassID;

  1095.     void* theQualifierData = &inClass;

  1096.     UInt32 subDevicesNum = 0;

  1097.     

  1098.     //---------------------------------------------------------------------------

  1099.     // Setup SR of both devices otherwise creating AD may fail...

  1100.     //---------------------------------------------------------------------------

  1101.     UInt32 keptclockdomain = 0;

  1102.     UInt32 clockdomain = 0;

  1103.     outSize = sizeof(UInt32);

  1104.     bool need_clock_drift_compensation = false;

  1105.     

  1106.     for (UInt32 i = 0; i < captureDeviceID.size(); i++) {

  1107.         if (SetupSampleRateAux(captureDeviceID[i], samplerate) < 0) {

  1108.             jack_error("JackCoreAudioDriver::CreateAggregateDevice : cannot set SR of input device");

  1109.         } else  {

  1110.             // Check clock domain

  1111.             osErr = AudioDeviceGetProperty(captureDeviceID[i], 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyClockDomain, &outSize, &clockdomain); 

  1112.             if (osErr != 0) {

  1113.                 jack_error("JackCoreAudioDriver::CreateAggregateDevice : kAudioDevicePropertyClockDomain error");

  1114.                 printError(osErr);

  1115.             } else {

  1116.                 keptclockdomain = (keptclockdomain == 0) ? clockdomain : keptclockdomain; 

  1117.                 jack_log("JackCoreAudioDriver::CreateAggregateDevice : input clockdomain = %d", clockdomain);

  1118.                 if (clockdomain != 0 && clockdomain != keptclockdomain) {

  1119.                     jack_error("JackCoreAudioDriver::CreateAggregateDevice : devices do not share the same clock!! clock drift compensation would be needed...");

  1120.                     need_clock_drift_compensation = true;

  1121.                 }

  1122.             }

  1123.         }

  1124.     }

  1125.     

  1126.     for (UInt32 i = 0; i < playbackDeviceID.size(); i++) {

  1127.         if (SetupSampleRateAux(playbackDeviceID[i], samplerate) < 0) {

  1128.             jack_error("JackCoreAudioDriver::CreateAggregateDevice : cannot set SR of output device");

  1129.         } else {

  1130.             // Check clock domain

  1131.             osErr = AudioDeviceGetProperty(playbackDeviceID[i], 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyClockDomain, &outSize, &clockdomain); 

  1132.             if (osErr != 0) {

  1133.                 jack_error("JackCoreAudioDriver::CreateAggregateDevice : kAudioDevicePropertyClockDomain error");

  1134.                 printError(osErr);

  1135.             } else {

  1136.                 keptclockdomain = (keptclockdomain == 0) ? clockdomain : keptclockdomain; 

  1137.                 jack_log("JackCoreAudioDriver::CreateAggregateDevice : output clockdomain = %d", clockdomain);

  1138.                 if (clockdomain != 0 && clockdomain != keptclockdomain) {

  1139.                     jack_error("JackCoreAudioDriver::CreateAggregateDevice : devices do not share the same clock!! clock drift compensation would be needed...");

  1140.                     need_clock_drift_compensation = true;

  1141.                 }

  1142.             }

  1143.         }

  1144.     }

  1145.     

  1146.     // If no valid clock domain was found, then assume we have to compensate...

  1147.     if (keptclockdomain == 0) {

  1148.         need_clock_drift_compensation = true;

  1149.     }

  1150.     

  1151.     //---------------------------------------------------------------------------

  1152.     // Start to create a new aggregate by getting the base audio hardware plugin

  1153.     //---------------------------------------------------------------------------

  1154.     

  1155.     char device_name[256];

  1156.     for (UInt32 i = 0; i < captureDeviceID.size(); i++) {

  1157.         GetDeviceNameFromID(captureDeviceID[i], device_name);

  1158.         jack_info("Separated input = '%s' ", device_name);

  1159.     }

  1160.     

  1161.     for (UInt32 i = 0; i < playbackDeviceID.size(); i++) {

  1162.         GetDeviceNameFromID(playbackDeviceID[i], device_name);

  1163.         jack_info("Separated output = '%s' ", device_name);

  1164.     }

  1165.     

  1166.     osErr = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyPlugInForBundleID, &outSize, &outWritable);

  1167.     if (osErr != noErr) {

  1168.         jack_error("JackCoreAudioDriver::CreateAggregateDevice : AudioHardwareGetPropertyInfo kAudioHardwarePropertyPlugInForBundleID error");

  1169.         printError(osErr);

  1170.         return osErr;

  1171.     }

  1172.     

  1173.     AudioValueTranslation pluginAVT;

  1174.     

  1175.     CFStringRef inBundleRef = CFSTR("com.apple.audio.CoreAudio");

  1176.     

  1177.     pluginAVT.mInputData = &inBundleRef;

  1178.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  1179.     pluginAVT.mOutputData = &fPluginID;

  1180.     pluginAVT.mOutputDataSize = sizeof(fPluginID);

  1181.     

  1182.     osErr = AudioHardwareGetProperty(kAudioHardwarePropertyPlugInForBundleID, &outSize, &pluginAVT);

  1183.     if (osErr != noErr) {

  1184.         jack_error("JackCoreAudioDriver::CreateAggregateDevice : AudioHardwareGetProperty kAudioHardwarePropertyPlugInForBundleID error");

  1185.         printError(osErr);

  1186.         return osErr;

  1187.     }

  1188.     

  1189.     //-------------------------------------------------

  1190.     // Create a CFDictionary for our aggregate device

  1191.     //-------------------------------------------------

  1192.     

  1193.     CFMutableDictionaryRef aggDeviceDict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);

  1194.     

  1195.     CFStringRef AggregateDeviceNameRef = CFSTR("JackDuplex");

  1196.     CFStringRef AggregateDeviceUIDRef = CFSTR("com.grame.JackDuplex");

  1197.     

  1198.     // add the name of the device to the dictionary

  1199.     CFDictionaryAddValue(aggDeviceDict, CFSTR(kAudioAggregateDeviceNameKey), AggregateDeviceNameRef);

  1200.     

  1201.     // add our choice of UID for the aggregate device to the dictionary

  1202.     CFDictionaryAddValue(aggDeviceDict, CFSTR(kAudioAggregateDeviceUIDKey), AggregateDeviceUIDRef);

  1203.     

  1204.     // add a "private aggregate key" to the dictionary

  1205.     int value = 1;

  1206.     CFNumberRef AggregateDeviceNumberRef = CFNumberCreate(NULL, kCFNumberIntType, &value);

  1207.     

  1208.     SInt32 system;

  1209.     Gestalt(gestaltSystemVersion, &system);

  1210.     

  1211.     jack_log("JackCoreAudioDriver::CreateAggregateDevice : system version = %x limit = %x", system, 0x00001054);

  1212.     

  1213.     // Starting with 10.5.4 systems, the AD can be internal... (better)

  1214.     if (system < 0x00001054) {

  1215.         jack_log("JackCoreAudioDriver::CreateAggregateDevice : public aggregate device....");

  1216.     } else {

  1217.         jack_log("JackCoreAudioDriver::CreateAggregateDevice : private aggregate device....");

  1218.         CFDictionaryAddValue(aggDeviceDict, CFSTR(kAudioAggregateDeviceIsPrivateKey), AggregateDeviceNumberRef);

  1219.     }

  1220.     

  1221.     // Prepare sub-devices for clock drift compensation

  1222.     CFMutableArrayRef subDevicesArrayClock = NULL;

  1223.     

  1224.     /*

  1225.      if (fClockDriftCompensate) {

  1226.      if (need_clock_drift_compensation) {

  1227.      jack_info("Clock drift compensation activated...");

  1228.      subDevicesArrayClock = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);

  1229.      

  1230.      for (UInt32 i = 0; i < captureDeviceID.size(); i++) {

  1231.      CFStringRef UID = GetDeviceName(captureDeviceID[i]);

  1232.      if (UID) {

  1233.      CFMutableDictionaryRef subdeviceAggDeviceDict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);

  1234.      CFDictionaryAddValue(subdeviceAggDeviceDict, CFSTR(kAudioSubDeviceUIDKey), UID);

  1235.      CFDictionaryAddValue(subdeviceAggDeviceDict, CFSTR(kAudioSubDeviceDriftCompensationKey), AggregateDeviceNumberRef);

  1236.      //CFRelease(UID);

  1237.      CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  1238.      }

  1239.      }

  1240.      

  1241.      for (UInt32 i = 0; i < playbackDeviceID.size(); i++) {

  1242.      CFStringRef UID = GetDeviceName(playbackDeviceID[i]);

  1243.      if (UID) {

  1244.      CFMutableDictionaryRef subdeviceAggDeviceDict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);

  1245.      CFDictionaryAddValue(subdeviceAggDeviceDict, CFSTR(kAudioSubDeviceUIDKey), UID);

  1246.      CFDictionaryAddValue(subdeviceAggDeviceDict, CFSTR(kAudioSubDeviceDriftCompensationKey), AggregateDeviceNumberRef);

  1247.      //CFRelease(UID);

  1248.      CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  1249.      }

  1250.      }

  1251.      

  1252.      // add sub-device clock array for the aggregate device to the dictionary

  1253.      CFDictionaryAddValue(aggDeviceDict, CFSTR(kAudioAggregateDeviceSubDeviceListKey), subDevicesArrayClock);

  1254.      } else {

  1255.      jack_info("Clock drift compensation was asked but is not needed (devices use the same clock domain)");

  1256.      }

  1257.      }

  1258.      */

  1259.     

  1260.     //-------------------------------------------------

  1261.     // Create a CFMutableArray for our sub-device list

  1262.     //-------------------------------------------------

  1263.     

  1264.     // we need to append the UID for each device to a CFMutableArray, so create one here

  1265.     CFMutableArrayRef subDevicesArray = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);

  1266.     

  1267.     vector<CFStringRef> captureDeviceUID;

  1268.     for (UInt32 i = 0; i < captureDeviceID.size(); i++) {

  1269.         CFStringRef ref = GetDeviceName(captureDeviceID[i]);

  1270.         if (ref == NULL)

  1271.             return -1;

  1272.         captureDeviceUID.push_back(ref);

  1273.         // input sub-devices in this example, so append the sub-device's UID to the CFArray

  1274.         CFArrayAppendValue(subDevicesArray, ref);

  1275.     }

  1276.     

  1277.     vector<CFStringRef> playbackDeviceUID;

  1278.     for (UInt32 i = 0; i < playbackDeviceID.size(); i++) {

  1279.         CFStringRef ref = GetDeviceName(playbackDeviceID[i]);

  1280.         if (ref == NULL)

  1281.             return -1;

  1282.         playbackDeviceUID.push_back(ref);

  1283.         // output sub-devices in this example, so append the sub-device's UID to the CFArray

  1284.         CFArrayAppendValue(subDevicesArray, ref);

  1285.     }

  1286.     

  1287.     //-----------------------------------------------------------------------

  1288.     // Feed the dictionary to the plugin, to create a blank aggregate device

  1289.     //-----------------------------------------------------------------------

  1290.     

  1291.     AudioObjectPropertyAddress pluginAOPA;

  1292.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  1293.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1294.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1295.     UInt32 outDataSize;

  1296.     

  1297.     osErr = AudioObjectGetPropertyDataSize(fPluginID, &pluginAOPA, 0, NULL, &outDataSize);

  1298.     if (osErr != noErr) {

  1299.         jack_error("JackCoreAudioDriver::CreateAggregateDevice : AudioObjectGetPropertyDataSize error");

  1300.         printError(osErr);

  1301.         goto error;

  1302.     }

  1303.     

  1304.     osErr = AudioObjectGetPropertyData(fPluginID, &pluginAOPA, sizeof(aggDeviceDict), &aggDeviceDict, &outDataSize, outAggregateDevice);

  1305.     if (osErr != noErr) {

  1306.         jack_error("JackCoreAudioDriver::CreateAggregateDevice : AudioObjectGetPropertyData error");

  1307.         printError(osErr);

  1308.         goto error;

  1309.     }

  1310.     

  1311.     // pause for a bit to make sure that everything completed correctly

  1312.     // this is to work around a bug in the HAL where a new aggregate device seems to disappear briefly after it is created

  1313.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1314.     

  1315.     //-------------------------

  1316.     // Set the sub-device list

  1317.     //-------------------------

  1318.     

  1319.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  1320.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1321.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1322.     outDataSize = sizeof(CFMutableArrayRef);

  1323.     osErr = AudioObjectSetPropertyData(*outAggregateDevice, &pluginAOPA, 0, NULL, outDataSize, &subDevicesArray);

  1324.     if (osErr != noErr) {

  1325.         jack_error("JackCoreAudioDriver::CreateAggregateDevice : AudioObjectSetPropertyData for sub-device list error");

  1326.         printError(osErr);

  1327.         goto error;

  1328.     }

  1329.     

  1330.     // pause again to give the changes time to take effect

  1331.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1332.     

  1333.     //-----------------------

  1334.     // Set the master device

  1335.     //-----------------------

  1336.     

  1337.     // set the master device manually (this is the device which will act as the master clock for the aggregate device)

  1338.     // pass in the UID of the device you want to use

  1339.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  1340.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1341.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1342.     outDataSize = sizeof(CFStringRef);

  1343.     osErr = AudioObjectSetPropertyData(*outAggregateDevice, &pluginAOPA, 0, NULL, outDataSize, &captureDeviceUID[0]);  // First apture is master...

  1344.     if (osErr != noErr) {

  1345.         jack_error("JackCoreAudioDriver::CreateAggregateDevice : AudioObjectSetPropertyData for master device error");

  1346.         printError(osErr);

  1347.         goto error;

  1348.     }

  1349.     

  1350.     // pause again to give the changes time to take effect

  1351.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1352.     

  1353.     // Prepare sub-devices for clock drift compensation

  1354.     // Workaround for bug in the HAL : until 10.6.2

  1355.     

  1356.     if (fClockDriftCompensate) {

  1357.         if (need_clock_drift_compensation) {

  1358.             jack_info("Clock drift compensation activated...");

  1359.             

  1360.             // Get the property data size

  1361.             osErr = AudioObjectGetPropertyDataSize(*outAggregateDevice, &theAddressOwned, theQualifierDataSize, theQualifierData, &outSize);

  1362.             if (osErr != noErr) {

  1363.                 jack_error("JackCoreAudioDriver::CreateAggregateDevice kAudioObjectPropertyOwnedObjects error");

  1364.                 printError(osErr);

  1365.             }

  1366.             

  1367.             //	Calculate the number of object IDs

  1368.             subDevicesNum = outSize / sizeof(AudioObjectID);

  1369.             jack_info("JackCoreAudioDriver::CreateAggregateDevice clock drift compensation, number of sub-devices = %d", subDevicesNum);

  1370.             AudioObjectID subDevices[subDevicesNum];

  1371.             outSize = sizeof(subDevices);

  1372.             

  1373.             osErr = AudioObjectGetPropertyData(*outAggregateDevice, &theAddressOwned, theQualifierDataSize, theQualifierData, &outSize, subDevices);

  1374.             if (osErr != noErr) {

  1375.                 jack_error("JackCoreAudioDriver::CreateAggregateDevice kAudioObjectPropertyOwnedObjects error");

  1376.                 printError(osErr);

  1377.             }

  1378.             

  1379.             // Set kAudioSubDevicePropertyDriftCompensation property...

  1380.             for (UInt32 index = 0; index < subDevicesNum; ++index) {

  1381.                 UInt32 theDriftCompensationValue = 1;

  1382.                 osErr = AudioObjectSetPropertyData(subDevices[index], &theAddressDrift, 0, NULL, sizeof(UInt32), &theDriftCompensationValue);

  1383.                 if (osErr != noErr) {

  1384.                     jack_error("JackCoreAudioDriver::CreateAggregateDevice kAudioSubDevicePropertyDriftCompensation error");

  1385.                     printError(osErr);

  1386.                 }

  1387.             }

  1388.         } else {

  1389.             jack_info("Clock drift compensation was asked but is not needed (devices use the same clock domain)");

  1390.         }

  1391.     }    

  1392.     

  1393.     // pause again to give the changes time to take effect

  1394.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1395.     

  1396.     //----------

  1397.     // Clean up

  1398.     //----------

  1399.     

  1400.     // release the private AD key

  1401.     CFRelease(AggregateDeviceNumberRef);

  1402.     

  1403.     // release the CF objects we have created - we don't need them any more

  1404.     CFRelease(aggDeviceDict);

  1405.     CFRelease(subDevicesArray);

  1406.     

  1407.     if (subDevicesArrayClock)

  1408.         CFRelease(subDevicesArrayClock);

  1409.     

  1410.     // release the device UID

  1411.     for (UInt32 i = 0; i < captureDeviceUID.size(); i++) {

  1412.         CFRelease(captureDeviceUID[i]);

  1413.     }

  1414.     

  1415.     for (UInt32 i = 0; i < playbackDeviceUID.size(); i++) {

  1416.         CFRelease(playbackDeviceUID[i]);

  1417.     }

  1418.     

  1419.     jack_log("New aggregate device %ld", *outAggregateDevice);

  1420.     return noErr;

  1421.     

  1422. error:

  1423.     DestroyAggregateDevice();

  1424.     return -1;

  1425. }

  1426.     

  1427.     

  1428. bool JackCoreAudioAdapter::IsAggregateDevice(AudioDeviceID device)

  1429. {

  1430.     OSStatus err = noErr;

  1431.     AudioObjectID sub_device[32];

  1432.     UInt32 outSize = sizeof(sub_device);

  1433.     err = AudioDeviceGetProperty(device, 0, kAudioDeviceSectionGlobal, kAudioAggregateDevicePropertyActiveSubDeviceList, &outSize, sub_device);

  1434.     

  1435.     if (err != noErr) {

  1436.         jack_log("Device does not have subdevices");

  1437.         return false;

  1438.     } else {

  1439.         int num_devices = outSize / sizeof(AudioObjectID);

  1440.         jack_log("Device does has %d subdevices", num_devices);

  1441.         return true;

  1442.     }

  1443. }

  1444. 

  1445. void JackCoreAudioAdapter::CloseAUHAL()

  1446. {

  1447.     AudioUnitUninitialize(fAUHAL);

  1448.     CloseComponent(fAUHAL);

  1449. }

  1450. 

  1451. int JackCoreAudioAdapter::Open()

  1452. {

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

  1454. }

  1455. 

  1456. int JackCoreAudioAdapter::Close()

  1457. {

  1458. #ifdef JACK_MONITOR

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

  1460. #endif

  1461.     AudioOutputUnitStop(fAUHAL);

  1462.     DisposeBuffers();

  1463.     CloseAUHAL();

  1464.     RemoveListeners();

  1465.     if (fPluginID > 0)

  1466.         DestroyAggregateDevice();

  1467.     return 0;

  1468. }

  1469. 

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

  1471.     JackAudioAdapterInterface::SetHostSampleRate ( sample_rate );

  1472.     Close();

  1473.     return Open();

  1474. }

  1475. 

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

  1477.     JackAudioAdapterInterface::SetHostBufferSize ( buffer_size );

  1478.     Close();

  1479.     return Open();

  1480. }

  1481. 

  1482. } // namespace

  1483. 

  1484. #ifdef __cplusplus

  1485. extern "C"

  1486. {

  1487. #endif

  1488. 

  1489.    SERVER_EXPORT jack_driver_desc_t* jack_get_descriptor()

  1490.    {

  1491.         jack_driver_desc_t *desc;

  1492.         unsigned int i;

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

  1494. 

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

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

  1497.      

  1498.         desc->nparams = 13;

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

  1500. 

  1501.         i = 0;

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

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

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

  1505.         desc->params[i].value.ui = -1;

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

  1507.         strcpy(desc->params[i].long_desc, "Maximum number of channels. If -1, max possible number of channels will be used");

  1508. 

  1509.         i++;

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

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

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

  1513.         desc->params[i].value.ui = -1;

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

  1515.         strcpy(desc->params[i].long_desc, "Maximum number of input channels. If -1, max possible number of input channels will be used");

  1516. 

  1517.         i++;

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

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

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

  1521.         desc->params[i].value.ui = -1;

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

  1523.         strcpy(desc->params[i].long_desc, "Maximum number of output channels. If -1, max possible number of output channels will be used");

  1524. 

  1525.         i++;

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

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

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

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

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

  1531. 

  1532.         i++;

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

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

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

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

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

  1538. 

  1539.         i++;

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

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

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

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

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

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

  1546. 

  1547.         i++;

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

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

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

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

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

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

  1554. 

  1555.         i++;

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

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

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

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

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

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

  1562. 

  1563.         i++;

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

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

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

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

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

  1569. 

  1570.         i++;

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

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

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

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

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

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

  1577.         

  1578.         i++;

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

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

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

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

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

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

  1585.         

  1586.         i++;

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

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

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

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

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

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

  1593.        

  1594.         i++;

  1595.         strcpy(desc->params[i].name, "clock-drift");

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

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

  1598.         desc->params[i].value.i = FALSE;

  1599.         strcpy(desc->params[i].short_desc, "Clock drift compensation");

  1600.         strcpy(desc->params[i].long_desc, "Whether to compensate clock drift in dynamically created aggregate device");

  1601.    

  1602.         return desc;

  1603.     }

  1604. 

  1605. 

  1606. #ifdef __cplusplus

  1607. }

  1608. #endif