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

1724 lines
65KB
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. 

  56.     deviceNum = size / sizeof(AudioDeviceID);

  57.     AudioDeviceID devices[deviceNum];

  58. 

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

  60.     if (err != noErr) {

  61.         return err;

  62.     }

  63. 

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

  65.         char device_name[256];

  66.         char internal_name[256];

  67. 

  68.         size = sizeof(CFStringRef);

  69.         UIname = NULL;

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

  71.         if (err == noErr) {

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

  73.         } else {

  74.             goto error;

  75.         }

  76. 

  77.         size = 256;

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

  79.         if (err != noErr) {

  80.             return err;

  81.         }

  82. 

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

  84.     }

  85. 

  86.     return noErr;

  87. 

  88. error:

  89.     if (UIname != NULL) {

  90.         CFRelease(UIname);

  91.     }

  92.     return err;

  93. }

  94. 

  95. static void printError(OSStatus err)

  96. {

  97.     switch (err) {

  98.         case kAudioHardwareNoError:

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

  100.             break;

  101.         case kAudioConverterErr_FormatNotSupported:

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

  103.             break;

  104.         case kAudioConverterErr_OperationNotSupported:

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

  106.             break;

  107.         case kAudioConverterErr_PropertyNotSupported:

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

  109.             break;

  110.         case kAudioConverterErr_InvalidInputSize:

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

  112.             break;

  113.         case kAudioConverterErr_InvalidOutputSize:

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

  115.             break;

  116.         case kAudioConverterErr_UnspecifiedError:

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

  118.             break;

  119.         case kAudioConverterErr_BadPropertySizeError:

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

  121.             break;

  122.         case kAudioConverterErr_RequiresPacketDescriptionsError:

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

  124.             break;

  125.         case kAudioConverterErr_InputSampleRateOutOfRange:

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

  127.             break;

  128.         case kAudioConverterErr_OutputSampleRateOutOfRange:

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

  130.             break;

  131.         case kAudioHardwareNotRunningError:

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

  133.             break;

  134.         case kAudioHardwareUnknownPropertyError:

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

  136.             break;

  137.         case kAudioHardwareIllegalOperationError:

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

  139.             break;

  140.         case kAudioHardwareBadDeviceError:

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

  142.             break;

  143.         case kAudioHardwareBadStreamError:

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

  145.             break;

  146.         case kAudioDeviceUnsupportedFormatError:

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

  148.             break;

  149.         case kAudioDevicePermissionsError:

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

  151.             break;

  152.         case kAudioHardwareBadObjectError:

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

  154.             break;

  155.         case kAudioHardwareUnsupportedOperationError:

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

  157.             break;

  158.         default:

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

  160.             break;

  161.     }

  162. }

  163. 

  164. OSStatus JackCoreAudioAdapter::SRNotificationCallback(AudioDeviceID inDevice,

  165.                                                         UInt32 inChannel,

  166.                                                         Boolean	isInput,

  167.                                                         AudioDevicePropertyID inPropertyID,

  168.                                                         void* inClientData)

  169. {

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

  171. 

  172.     switch (inPropertyID) {

  173. 

  174.         case kAudioDevicePropertyNominalSampleRate: {

  175.             jack_log("JackCoreAudioAdapter::SRNotificationCallback kAudioDevicePropertyNominalSampleRate");

  176.             driver->fState = true;

  177.             break;

  178.         }

  179.     }

  180. 

  181.     return noErr;

  182. }

  183. 

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

  185. OSStatus JackCoreAudioAdapter::DeviceNotificationCallback(AudioDeviceID inDevice,

  186.         UInt32 inChannel,

  187.         Boolean	isInput,

  188.         AudioDevicePropertyID inPropertyID,

  189.         void* inClientData)

  190. {

  191. 

  192.     switch (inPropertyID) {

  193. 

  194.         case kAudioDeviceProcessorOverload: {

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

  196.             break;

  197. 		}

  198. 

  199.         case kAudioDevicePropertyStreamConfiguration: {

  200.             jack_error("Cannot handle kAudioDevicePropertyStreamConfiguration");

  201.             return kAudioHardwareUnsupportedOperationError;

  202.         }

  203. 

  204.         case kAudioDevicePropertyNominalSampleRate: {

  205.             jack_error("Cannot handle kAudioDevicePropertyNominalSampleRate");

  206.             return kAudioHardwareUnsupportedOperationError;

  207.         }

  208. 

  209.     }

  210.     return noErr;

  211. }

  212. 

  213. int JackCoreAudioAdapter::AddListeners()

  214. {

  215.     OSStatus err = noErr;

  216. 

  217.     // Add listeners

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

  219.     if (err != noErr) {

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

  221.         printError(err);

  222.         return -1;

  223.     }

  224. 

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

  226.     if (err != noErr) {

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

  228.         printError(err);

  229.         return -1;

  230.     }

  231. 

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

  233.     if (err != noErr) {

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

  235.         printError(err);

  236.         return -1;

  237.     }

  238. 

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

  240.     if (err != noErr) {

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

  242.         printError(err);

  243.         return -1;

  244.     }

  245. 

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

  247.     if (err != noErr) {

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

  249.         printError(err);

  250.         return -1;

  251.     }

  252. 

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

  254.     if (err != noErr) {

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

  256.         printError(err);

  257.         return -1;

  258.     }

  259. 

  260.     return 0;

  261. }

  262. 

  263. void JackCoreAudioAdapter::RemoveListeners()

  264. {

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

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

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

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

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

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

  271. }

  272. 

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

  274.                                     AudioUnitRenderActionFlags *ioActionFlags,

  275.                                     const AudioTimeStamp *inTimeStamp,

  276.                                     UInt32 inBusNumber,

  277.                                     UInt32 inNumberFrames,

  278.                                     AudioBufferList *ioData)

  279. {

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

  281.     OSStatus err = AudioUnitRender(adapter->fAUHAL, ioActionFlags, inTimeStamp, 1, inNumberFrames, adapter->fInputData);

  282. 

  283.     if (err == noErr) {

  284.         jack_default_audio_sample_t* inputBuffer[adapter->fCaptureChannels];

  285.         jack_default_audio_sample_t* outputBuffer[adapter->fPlaybackChannels];

  286. 

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

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

  289.         }

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

  291.             outputBuffer[i] = (jack_default_audio_sample_t*)ioData->mBuffers[i].mData;

  292.         }

  293. 

  294.         adapter->PushAndPull((jack_default_audio_sample_t**)inputBuffer, (jack_default_audio_sample_t**)outputBuffer, inNumberFrames);

  295.         return noErr;

  296.     } else {

  297.         return err;

  298.     }

  299. }

  300. 

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

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

  303. {

  304.     const JSList* node;

  305.     const jack_driver_param_t* param;

  306.     int in_nChannels = 0;

  307.     int out_nChannels = 0;

  308.     char captureName[256];

  309.     char playbackName[256];

  310.     fCaptureUID[0] = 0;

  311.     fPlaybackUID[0] = 0;

  312.     fClockDriftCompensate = false;

  313. 

  314.     // Default values

  315.     fCaptureChannels = -1;

  316.     fPlaybackChannels = -1;

  317. 

  318.     SInt32 major;

  319.     SInt32 minor;

  320.     Gestalt(gestaltSystemVersionMajor, &major);

  321.     Gestalt(gestaltSystemVersionMinor, &minor);

  322. 

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

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

  325.         CFRunLoopRef theRunLoop = NULL;

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

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

  328.         if (theError != noErr) {

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

  330.         }

  331.     }

  332. 

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

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

  335. 

  336.         switch (param->character) {

  337. 

  338.             case 'c' :

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

  340.                 break;

  341. 

  342.             case 'i':

  343.                 fCaptureChannels = param->value.ui;

  344.                 break;

  345. 

  346.             case 'o':

  347.                 fPlaybackChannels = param->value.ui;

  348.                 break;

  349. 

  350.             case 'C':

  351.                 fCapturing = true;

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

  353.                 break;

  354. 

  355.             case 'P':

  356.                 fPlaying = true;

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

  358.                 break;

  359. 

  360.             case 'd':

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

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

  363.                 break;

  364. 

  365.             case 'D':

  366.                 fCapturing = fPlaying = true;

  367.                 break;

  368. 

  369.             case 'r':

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

  371.                 break;

  372. 

  373.             case 'p':

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

  375.                 break;

  376. 

  377.             case 'l':

  378.                 DisplayDeviceNames();

  379.                 break;

  380. 

  381.             case 'q':

  382.                 fQuality = param->value.ui;

  383.                 break;

  384. 

  385.             case 'g':

  386.                 fRingbufferCurSize = param->value.ui;

  387.                 fAdaptative = false;

  388.                 break;

  389. 

  390.             case 's':

  391.                 fClockDriftCompensate = true;

  392.                 break;

  393.         }

  394.     }

  395. 

  396.     /* duplex is the default */

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

  398.         fCapturing = true;

  399.         fPlaying = true;

  400.     }

  401. 

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

  403.        throw std::bad_alloc();

  404.     }

  405. 

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

  407.         throw std::bad_alloc();

  408.     }

  409. 

  410.     if (SetupBufferSize(fAdaptedBufferSize) < 0) {

  411.         throw std::bad_alloc();

  412.     }

  413. 

  414.     if (SetupSampleRate(fAdaptedSampleRate) < 0) {

  415.         throw std::bad_alloc();

  416.     }

  417. 

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

  419.         throw std::bad_alloc();

  420.     }

  421. 

  422.     if (fCapturing && fCaptureChannels > 0) {

  423.         if (SetupBuffers(fCaptureChannels) < 0) {

  424.             throw std::bad_alloc();

  425.         }

  426.     }

  427. 

  428.     if (AddListeners() < 0) {

  429.         throw std::bad_alloc();

  430.     }

  431. 

  432.     GetStreamLatencies(fDeviceID, true, fInputLatencies);

  433.     GetStreamLatencies(fDeviceID, false, fOutputLatencies);

  434. }

  435. 

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

  437. {

  438.     OSStatus res;

  439.     UInt32 theSize = sizeof(UInt32);

  440.     AudioDeviceID inDefault;

  441.     AudioDeviceID outDefault;

  442. 

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

  444.         return res;

  445.     }

  446. 

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

  448.         return res;

  449.     }

  450. 

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

  452. 

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

  454.     if (inDefault != outDefault) {

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

  456.         return kAudioHardwareBadDeviceError;

  457.     } else if (inDefault == 0) {

  458.         jack_error("Default input and output devices are null !!");

  459.         return kAudioHardwareBadDeviceError;

  460.     } else {

  461.         *id = inDefault;

  462.         return noErr;

  463.     }

  464. }

  465. 

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

  467. {

  468.     OSStatus err = noErr;

  469.     UInt32	outSize;

  470.     Boolean	outWritable;

  471. 

  472.     channelCount = 0;

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

  474.     if (err == noErr) {

  475.         AudioBufferList bufferList[outSize];

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

  477.         if (err == noErr) {

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

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

  480.             }

  481.         }

  482.     }

  483. 

  484.     return err;

  485. }

  486. 

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

  488. {

  489.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  492. 

  493.     if (inIUD == NULL) {

  494.         return kAudioHardwareUnspecifiedError;

  495.     } else {

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

  497.         CFRelease(inIUD);

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

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

  500.     }

  501. }

  502. 

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

  504. {

  505.     OSStatus res;

  506.     UInt32 theSize = sizeof(UInt32);

  507.     AudioDeviceID inDefault;

  508. 

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

  510.         return res;

  511.     }

  512. 

  513.     if (inDefault == 0) {

  514.         jack_error("Error: default input device is 0, please select a correct one !!");

  515.         return -1;

  516.     }

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

  518.     *id = inDefault;

  519.     return noErr;

  520. }

  521. 

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

  523. {

  524.     OSStatus res;

  525.     UInt32 theSize = sizeof(UInt32);

  526.     AudioDeviceID outDefault;

  527. 

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

  529.         return res;

  530.     }

  531. 

  532.     if (outDefault == 0) {

  533.         jack_error("Error: default output device is 0, please select a correct one !!");

  534.         return -1;

  535.     }

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

  537.     *id = outDefault;

  538.     return noErr;

  539. }

  540. 

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

  542. {

  543.     UInt32 size = 256;

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

  545. }

  546. 

  547. AudioDeviceID JackCoreAudioAdapter::GetDeviceIDFromName(const char* name)

  548. {

  549.     UInt32 size;

  550.     Boolean isWritable;

  551.     int i, deviceNum;

  552. 

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

  554.     if (err != noErr) {

  555.         return -1;

  556.     }

  557. 

  558.     deviceNum = size / sizeof(AudioDeviceID);

  559.     AudioDeviceID devices[deviceNum];

  560. 

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

  562.     if (err != noErr) {

  563.         return err;

  564.     }

  565. 

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

  567.         char device_name[256];

  568.         size = 256;

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

  570.         if (err != noErr) {

  571.             return -1;

  572.         } else if (strcmp(device_name, name) == 0) {

  573.             return devices[i];

  574.         }

  575.     }

  576. 

  577.     return -1;

  578. }

  579. 

  580. // Setup

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

  582.                                         const char* playback_driver_uid,

  583.                                         char* capture_driver_name,

  584.                                         char* playback_driver_name,

  585.                                         jack_nframes_t samplerate)

  586. {

  587.     capture_driver_name[0] = 0;

  588.     playback_driver_name[0] = 0;

  589. 

  590.     // Duplex

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

  592.         jack_log("JackCoreAudioDriver::Open duplex");

  593. 

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

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

  596. 

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

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

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

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

  601.                     return -1;

  602.                 }

  603.             }

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

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

  606.                 return -1;

  607.             }

  608. 

  609.         } else {

  610. 

  611.             // Creates aggregate device

  612.             AudioDeviceID captureID, playbackID;

  613. 

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

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

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

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

  618.                     return -1;

  619.                 }

  620.             }

  621. 

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

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

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

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

  626.                     return -1;

  627.                 }

  628.             }

  629. 

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

  631.                 return -1;

  632.             }

  633.         }

  634. 

  635.     // Capture only

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

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

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

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

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

  641.                 return -1;

  642.             }

  643.         }

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

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

  646.             return -1;

  647.         }

  648. 

  649.     // Playback only

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

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

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

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

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

  655.                 return -1;

  656.             }

  657.         }

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

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

  660.             return -1;

  661.         }

  662. 

  663.     // Use default driver in duplex mode

  664.     } else {

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

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

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

  668. 

  669.             // Creates aggregate device

  670.             AudioDeviceID captureID = -1, playbackID = -1;

  671. 

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

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

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

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

  676.                     goto built_in;

  677.                 }

  678.             }

  679. 

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

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

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

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

  684.                     goto built_in;

  685.                 }

  686.             }

  687. 

  688.             if (captureID > 0 && playbackID > 0) {

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

  690.                     goto built_in;

  691.                 }

  692.             } else {

  693.                 jack_error("Cannot use default input/output");

  694.                 goto built_in;

  695.             }

  696.         }

  697.     }

  698. 

  699.     return 0;

  700. 

  701. built_in:

  702. 

  703.     // Aggregate built-in input and output

  704.     AudioDeviceID captureID = GetDeviceIDFromName("Built-in Input");

  705.     AudioDeviceID playbackID = GetDeviceIDFromName("Built-in Output");

  706. 

  707.     if (captureID > 0 && playbackID > 0) {

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

  709.             return -1;

  710.         }

  711.     } else {

  712.         jack_error("Cannot aggregate built-in input and output");

  713.         return -1;

  714.     }

  715. 

  716.     return 0;

  717. }

  718. 

  719. int JackCoreAudioAdapter::SetupChannels(bool capturing,

  720.                                         bool playing,

  721.                                         int& inchannels,

  722.                                         int& outchannels,

  723.                                         int& in_nChannels,

  724.                                         int& out_nChannels,

  725.                                         bool strict)

  726. {

  727.     OSStatus err = noErr;

  728. 

  729.     if (capturing) {

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

  731.         if (err != noErr) {

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

  733.             printError(err);

  734.             return -1;

  735.         } else {

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

  737.         }

  738.     }

  739. 

  740.     if (playing) {

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

  742.         if (err != noErr) {

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

  744.             printError(err);

  745.             return -1;

  746.         } else {

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

  748.         }

  749.     }

  750. 

  751.     if (inchannels > in_nChannels) {

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

  753.         if (strict) {

  754.             return -1;

  755.         }

  756.     }

  757. 

  758.     if (outchannels > out_nChannels) {

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

  760.         if (strict) {

  761.             return -1;

  762.         }

  763.     }

  764. 

  765.     if (inchannels == -1) {

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

  767.         inchannels = in_nChannels;

  768.     }

  769. 

  770.     if (outchannels == -1) {

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

  772.         outchannels = out_nChannels;

  773.     }

  774. 

  775.     return 0;

  776. }

  777. 

  778. int JackCoreAudioAdapter::SetupBufferSize(jack_nframes_t buffer_size)

  779. {

  780.     // Setting buffer size

  781.     UInt32 outSize = sizeof(UInt32);

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

  783.     if (err != noErr) {

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

  785.         printError(err);

  786.         return -1;

  787.     }

  788. 

  789.     return 0;

  790. }

  791. 

  792. int JackCoreAudioAdapter::SetupSampleRate(jack_nframes_t samplerate)

  793. {

  794.     return SetupSampleRateAux(fDeviceID, samplerate);

  795. }

  796. 

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

  798. {

  799.     OSStatus err = noErr;

  800.     UInt32 outSize;

  801.     Float64 sampleRate;

  802. 

  803.     // Get sample rate

  804.     outSize =  sizeof(Float64);

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

  806.     if (err != noErr) {

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

  808.         printError(err);

  809.         return -1;

  810.     } else {

  811.         jack_log("Current sample rate = %f", sampleRate);

  812.     }

  813. 

  814.     // If needed, set new sample rate

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

  816.         sampleRate = (Float64)samplerate;

  817. 

  818.         // To get SR change notification

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

  820.         if (err != noErr) {

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

  822.             printError(err);

  823.             return -1;

  824.         }

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

  826.         if (err != noErr) {

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

  828.             printError(err);

  829.             return -1;

  830.         }

  831. 

  832.         // Waiting for SR change notification

  833.         int count = 0;

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

  835.             usleep(100000);

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

  837.         }

  838. 

  839.         // Remove SR change notification

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

  841.     }

  842. 

  843.     return 0;

  844. }

  845. 

  846. int JackCoreAudioAdapter::SetupBuffers(int inchannels)

  847. {

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

  849. 

  850.     // Prepare buffers

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

  852.     fInputData->mNumberBuffers = inchannels;

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

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

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

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

  857.     }

  858.     return 0;

  859. }

  860. 

  861. void JackCoreAudioAdapter::DisposeBuffers()

  862. {

  863.     if (fInputData) {

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

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

  866.         }

  867.         free(fInputData);

  868.         fInputData = 0;

  869.     }

  870. }

  871. 

  872. int JackCoreAudioAdapter::OpenAUHAL(bool capturing,

  873.                                    bool playing,

  874.                                    int inchannels,

  875.                                    int outchannels,

  876.                                    int in_nChannels,

  877.                                    int out_nChannels,

  878.                                    jack_nframes_t buffer_size,

  879.                                    jack_nframes_t samplerate)

  880. {

  881.     ComponentResult err1;

  882.     UInt32 enableIO;

  883.     AudioStreamBasicDescription srcFormat, dstFormat;

  884.     AudioDeviceID currAudioDeviceID;

  885.     UInt32 size;

  886. 

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

  888. 

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

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

  891.         return -1;

  892.     }

  893. 

  894.     // AUHAL

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

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

  897. 

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

  899.     if (err1 != noErr) {

  900.         jack_error("Error calling OpenAComponent");

  901.         printError(err1);

  902.         goto error;

  903.     }

  904. 

  905.     err1 = AudioUnitInitialize(fAUHAL);

  906.     if (err1 != noErr) {

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

  908.         printError(err1);

  909.         goto error;

  910.     }

  911. 

  912.     // Start I/O

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

  914.         enableIO = 1;

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

  916.     } else {

  917.         enableIO = 0;

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

  919.     }

  920. 

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

  922.     if (err1 != noErr) {

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

  924.         printError(err1);

  925.         goto error;

  926.     }

  927. 

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

  929.         enableIO = 1;

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

  931.     } else {

  932.         enableIO = 0;

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

  934.     }

  935. 

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

  937.     if (err1 != noErr) {

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

  939.         printError(err1);

  940.         goto error;

  941.     }

  942. 

  943.     size = sizeof(AudioDeviceID);

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

  945.     if (err1 != noErr) {

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

  947.         printError(err1);

  948.         goto error;

  949.     } else {

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

  951.     }

  952. 

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

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

  955.     if (err1 != noErr) {

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

  957.         printError(err1);

  958.         goto error;

  959.     }

  960. 

  961.     // Set buffer size

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

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

  964.         if (err1 != noErr) {

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

  966.             printError(err1);

  967.             goto error;

  968.         }

  969.     }

  970. 

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

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

  973.         if (err1 != noErr) {

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

  975.             printError(err1);

  976.             goto error;

  977.         }

  978.     }

  979. 

  980.     // Setup channel map

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

  982.         SInt32 chanArr[in_nChannels];

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

  984.             chanArr[i] = -1;

  985.         }

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

  987.             chanArr[i] = i;

  988.         }

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

  990.         if (err1 != noErr) {

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

  992.             printError(err1);

  993.             goto error;

  994.         }

  995.     }

  996. 

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

  998.         SInt32 chanArr[out_nChannels];

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

  1000.             chanArr[i] = -1;

  1001.         }

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

  1003.             chanArr[i] = i;

  1004.         }

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

  1006.         if (err1 != noErr) {

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

  1008.             printError(err1);

  1009.             goto error;

  1010.         }

  1011.     }

  1012. 

  1013.     // Setup stream converters

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

  1015. 

  1016.         size = sizeof(AudioStreamBasicDescription);

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

  1018.         if (err1 != noErr) {

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

  1020.             printError(err1);

  1021.             goto error;

  1022.         }

  1023.         PrintStreamDesc(&srcFormat);

  1024. 

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

  1026.         srcFormat.mSampleRate = samplerate;

  1027.         srcFormat.mFormatID = kAudioFormatLinearPCM;

  1028.         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1029.         srcFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1030.         srcFormat.mFramesPerPacket = 1;

  1031.         srcFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1032.         srcFormat.mChannelsPerFrame = inchannels;

  1033.         srcFormat.mBitsPerChannel = 32;

  1034.         PrintStreamDesc(&srcFormat);

  1035. 

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

  1037. 

  1038.         if (err1 != noErr) {

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

  1040.             printError(err1);

  1041.             goto error;

  1042.         }

  1043.     }

  1044. 

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

  1046. 

  1047.         size = sizeof(AudioStreamBasicDescription);

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

  1049.         if (err1 != noErr) {

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

  1051.             printError(err1);

  1052.             goto error;

  1053.         }

  1054.         PrintStreamDesc(&dstFormat);

  1055. 

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

  1057.         dstFormat.mSampleRate = samplerate;

  1058.         dstFormat.mFormatID = kAudioFormatLinearPCM;

  1059.         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1060.         dstFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1061.         dstFormat.mFramesPerPacket = 1;

  1062.         dstFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1063.         dstFormat.mChannelsPerFrame = outchannels;

  1064.         dstFormat.mBitsPerChannel = 32;

  1065.         PrintStreamDesc(&dstFormat);

  1066. 

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

  1068. 

  1069.         if (err1 != noErr) {

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

  1071.             printError(err1);

  1072.             goto error;

  1073.         }

  1074.     }

  1075. 

  1076.     // Setup callbacks

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

  1078.         AURenderCallbackStruct output;

  1079.         output.inputProc = Render;

  1080.         output.inputProcRefCon = this;

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

  1082.         if (err1 != noErr) {

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

  1084.             printError(err1);

  1085.             goto error;

  1086.         }

  1087.     } else {

  1088.         AURenderCallbackStruct output;

  1089.         output.inputProc = Render;

  1090.         output.inputProcRefCon = this;

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

  1092.         if (err1 != noErr) {

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

  1094.             printError(err1);

  1095.             goto error;

  1096.         }

  1097.     }

  1098. 

  1099.     return 0;

  1100. 

  1101. error:

  1102.     CloseAUHAL();

  1103.     return -1;

  1104. }

  1105. 

  1106. OSStatus JackCoreAudioAdapter::DestroyAggregateDevice()

  1107. {

  1108.     OSStatus osErr = noErr;

  1109.     AudioObjectPropertyAddress pluginAOPA;

  1110.     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;

  1111.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1112.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1113.     UInt32 outDataSize;

  1114. 

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

  1116.     if (osErr != noErr) {

  1117.         jack_error("JackCoreAudioAdapter::DestroyAggregateDevice : AudioObjectGetPropertyDataSize error");

  1118.         printError(osErr);

  1119.         return osErr;

  1120.     }

  1121. 

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

  1123.     if (osErr != noErr) {

  1124.         jack_error("JackCoreAudioAdapter::DestroyAggregateDevice : AudioObjectGetPropertyData error");

  1125.         printError(osErr);

  1126.         return osErr;

  1127.     }

  1128. 

  1129.     return noErr;

  1130. }

  1131. 

  1132. static CFStringRef GetDeviceName(AudioDeviceID id)

  1133. {

  1134.     UInt32 size = sizeof(CFStringRef);

  1135.     CFStringRef UIname;

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

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

  1138. }

  1139. 

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

  1141. {

  1142.     OSStatus err = noErr;

  1143.     AudioObjectID sub_device[32];

  1144.     UInt32 outSize = sizeof(sub_device);

  1145. 

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

  1147.     vector<AudioDeviceID> captureDeviceIDArray;

  1148. 

  1149.     if (err != noErr) {

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

  1151.         captureDeviceIDArray.push_back(captureDeviceID);

  1152.     } else {

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

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

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

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

  1157.         }

  1158.     }

  1159. 

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

  1161.     vector<AudioDeviceID> playbackDeviceIDArray;

  1162. 

  1163.     if (err != noErr) {

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

  1165.         playbackDeviceIDArray.push_back(playbackDeviceID);

  1166.     } else {

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

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

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

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

  1171.         }

  1172.     }

  1173. 

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

  1175. }

  1176. 

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

  1178. {

  1179.     OSStatus osErr = noErr;

  1180.     UInt32 outSize;

  1181.     Boolean outWritable;

  1182. 

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

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

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

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

  1187.     UInt32 theQualifierDataSize = sizeof(AudioObjectID);

  1188.     AudioClassID inClass = kAudioSubDeviceClassID;

  1189.     void* theQualifierData = &inClass;

  1190.     UInt32 subDevicesNum = 0;

  1191. 

  1192.     //---------------------------------------------------------------------------

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

  1194.     //---------------------------------------------------------------------------

  1195.     UInt32 keptclockdomain = 0;

  1196.     UInt32 clockdomain = 0;

  1197.     outSize = sizeof(UInt32);

  1198.     bool need_clock_drift_compensation = false;

  1199. 

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

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

  1202.             jack_error("JackCoreAudioAdapter::CreateAggregateDevice : cannot set SR of input device");

  1203.         } else  {

  1204.             // Check clock domain

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

  1206.             if (osErr != 0) {

  1207.                 jack_error("JackCoreAudioAdapter::CreateAggregateDevice : kAudioDevicePropertyClockDomain error");

  1208.                 printError(osErr);

  1209.             } else {

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

  1211.                 jack_log("JackCoreAudioAdapter::CreateAggregateDevice : input clockdomain = %d", clockdomain);

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

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

  1214.                     need_clock_drift_compensation = true;

  1215.                 }

  1216.             }

  1217.         }

  1218.     }

  1219. 

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

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

  1222.             jack_error("JackCoreAudioAdapter::CreateAggregateDevice : cannot set SR of output device");

  1223.         } else {

  1224.             // Check clock domain

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

  1226.             if (osErr != 0) {

  1227.                 jack_error("JackCoreAudioAdapter::CreateAggregateDevice : kAudioDevicePropertyClockDomain error");

  1228.                 printError(osErr);

  1229.             } else {

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

  1231.                 jack_log("JackCoreAudioAdapter::CreateAggregateDevice : output clockdomain = %d", clockdomain);

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

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

  1234.                     need_clock_drift_compensation = true;

  1235.                 }

  1236.             }

  1237.         }

  1238.     }

  1239. 

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

  1241.     if (keptclockdomain == 0) {

  1242.         need_clock_drift_compensation = true;

  1243.     }

  1244. 

  1245.     //---------------------------------------------------------------------------

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

  1247.     //---------------------------------------------------------------------------

  1248. 

  1249.     char device_name[256];

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

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

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

  1253.     }

  1254. 

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

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

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

  1258.     }

  1259. 

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

  1261.     if (osErr != noErr) {

  1262.         jack_error("JackCoreAudioAdapter::CreateAggregateDevice : AudioHardwareGetPropertyInfo kAudioHardwarePropertyPlugInForBundleID error");

  1263.         printError(osErr);

  1264.         return osErr;

  1265.     }

  1266. 

  1267.     AudioValueTranslation pluginAVT;

  1268. 

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

  1270. 

  1271.     pluginAVT.mInputData = &inBundleRef;

  1272.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  1273.     pluginAVT.mOutputData = &fPluginID;

  1274.     pluginAVT.mOutputDataSize = sizeof(fPluginID);

  1275. 

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

  1277.     if (osErr != noErr) {

  1278.         jack_error("JackCoreAudioAdapter::CreateAggregateDevice : AudioHardwareGetProperty kAudioHardwarePropertyPlugInForBundleID error");

  1279.         printError(osErr);

  1280.         return osErr;

  1281.     }

  1282. 

  1283.     //-------------------------------------------------

  1284.     // Create a CFDictionary for our aggregate device

  1285.     //-------------------------------------------------

  1286. 

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

  1288. 

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

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

  1291. 

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

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

  1294. 

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

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

  1297. 

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

  1299.     int value = 1;

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

  1301. 

  1302.     SInt32 system;

  1303.     Gestalt(gestaltSystemVersion, &system);

  1304. 

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

  1306. 

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

  1308.     if (system < 0x00001054) {

  1309.         jack_log("JackCoreAudioAdapter::CreateAggregateDevice : public aggregate device....");

  1310.     } else {

  1311.         jack_log("JackCoreAudioAdapter::CreateAggregateDevice : private aggregate device....");

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

  1313.     }

  1314. 

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

  1316.     CFMutableArrayRef subDevicesArrayClock = NULL;

  1317. 

  1318.     /*

  1319.      if (fClockDriftCompensate) {

  1320.      if (need_clock_drift_compensation) {

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

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

  1323. 

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

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

  1326.      if (UID) {

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

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

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

  1330.      //CFRelease(UID);

  1331.      CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  1332.      }

  1333.      }

  1334. 

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

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

  1337.      if (UID) {

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

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

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

  1341.      //CFRelease(UID);

  1342.      CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  1343.      }

  1344.      }

  1345. 

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

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

  1348.      } else {

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

  1350.      }

  1351.      }

  1352.      */

  1353. 

  1354.     //-------------------------------------------------

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

  1356.     //-------------------------------------------------

  1357. 

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

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

  1360. 

  1361.     vector<CFStringRef> captureDeviceUID;

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

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

  1364.         if (ref == NULL) {

  1365.             return -1;

  1366.         }

  1367.         captureDeviceUID.push_back(ref);

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

  1369.         CFArrayAppendValue(subDevicesArray, ref);

  1370.     }

  1371. 

  1372.     vector<CFStringRef> playbackDeviceUID;

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

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

  1375.         if (ref == NULL) {

  1376.             return -1;

  1377.         }

  1378.         playbackDeviceUID.push_back(ref);

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

  1380.         CFArrayAppendValue(subDevicesArray, ref);

  1381.     }

  1382. 

  1383.     //-----------------------------------------------------------------------

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

  1385.     //-----------------------------------------------------------------------

  1386. 

  1387.     AudioObjectPropertyAddress pluginAOPA;

  1388.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  1389.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1390.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1391.     UInt32 outDataSize;

  1392. 

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

  1394.     if (osErr != noErr) {

  1395.         jack_error("JackCoreAudioAdapter::CreateAggregateDevice : AudioObjectGetPropertyDataSize error");

  1396.         printError(osErr);

  1397.         goto error;

  1398.     }

  1399. 

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

  1401.     if (osErr != noErr) {

  1402.         jack_error("JackCoreAudioAdapter::CreateAggregateDevice : AudioObjectGetPropertyData error");

  1403.         printError(osErr);

  1404.         goto error;

  1405.     }

  1406. 

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

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

  1409.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1410. 

  1411.     //-------------------------

  1412.     // Set the sub-device list

  1413.     //-------------------------

  1414. 

  1415.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  1416.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1417.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1418.     outDataSize = sizeof(CFMutableArrayRef);

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

  1420.     if (osErr != noErr) {

  1421.         jack_error("JackCoreAudioAdapter::CreateAggregateDevice : AudioObjectSetPropertyData for sub-device list error");

  1422.         printError(osErr);

  1423.         goto error;

  1424.     }

  1425. 

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

  1427.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1428. 

  1429.     //-----------------------

  1430.     // Set the master device

  1431.     //-----------------------

  1432. 

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

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

  1435.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  1436.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1437.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1438.     outDataSize = sizeof(CFStringRef);

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

  1440.     if (osErr != noErr) {

  1441.         jack_error("JackCoreAudioAdapter::CreateAggregateDevice : AudioObjectSetPropertyData for master device error");

  1442.         printError(osErr);

  1443.         goto error;

  1444.     }

  1445. 

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

  1447.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1448. 

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

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

  1451. 

  1452.     if (fClockDriftCompensate) {

  1453.         if (need_clock_drift_compensation) {

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

  1455. 

  1456.             // Get the property data size

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

  1458.             if (osErr != noErr) {

  1459.                 jack_error("JackCoreAudioAdapter::CreateAggregateDevice kAudioObjectPropertyOwnedObjects error");

  1460.                 printError(osErr);

  1461.             }

  1462. 

  1463.             //	Calculate the number of object IDs

  1464.             subDevicesNum = outSize / sizeof(AudioObjectID);

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

  1466.             AudioObjectID subDevices[subDevicesNum];

  1467.             outSize = sizeof(subDevices);

  1468. 

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

  1470.             if (osErr != noErr) {

  1471.                 jack_error("JackCoreAudioAdapter::CreateAggregateDevice kAudioObjectPropertyOwnedObjects error");

  1472.                 printError(osErr);

  1473.             }

  1474. 

  1475.             // Set kAudioSubDevicePropertyDriftCompensation property...

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

  1477.                 UInt32 theDriftCompensationValue = 1;

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

  1479.                 if (osErr != noErr) {

  1480.                     jack_error("JackCoreAudioAdapter::CreateAggregateDevice kAudioSubDevicePropertyDriftCompensation error");

  1481.                     printError(osErr);

  1482.                 }

  1483.             }

  1484.         } else {

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

  1486.         }

  1487.     }

  1488. 

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

  1490.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1491. 

  1492.     //----------

  1493.     // Clean up

  1494.     //----------

  1495. 

  1496.     // release the private AD key

  1497.     CFRelease(AggregateDeviceNumberRef);

  1498. 

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

  1500.     CFRelease(aggDeviceDict);

  1501.     CFRelease(subDevicesArray);

  1502. 

  1503.     if (subDevicesArrayClock) {

  1504.         CFRelease(subDevicesArrayClock);

  1505.     }

  1506. 

  1507.     // release the device UID

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

  1509.         CFRelease(captureDeviceUID[i]);

  1510.     }

  1511. 

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

  1513.         CFRelease(playbackDeviceUID[i]);

  1514.     }

  1515. 

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

  1517.     return noErr;

  1518. 

  1519. error:

  1520.     DestroyAggregateDevice();

  1521.     return -1;

  1522. }

  1523. 

  1524. 

  1525. bool JackCoreAudioAdapter::IsAggregateDevice(AudioDeviceID device)

  1526. {

  1527.     OSStatus err = noErr;

  1528.     AudioObjectID sub_device[32];

  1529.     UInt32 outSize = sizeof(sub_device);

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

  1531. 

  1532.     if (err != noErr) {

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

  1534.         return false;

  1535.     } else {

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

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

  1538.         return true;

  1539.     }

  1540. }

  1541. 

  1542. void JackCoreAudioAdapter::CloseAUHAL()

  1543. {

  1544.     AudioUnitUninitialize(fAUHAL);

  1545.     CloseComponent(fAUHAL);

  1546. }

  1547. 

  1548. int JackCoreAudioAdapter::Open()

  1549. {

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

  1551. }

  1552. 

  1553. int JackCoreAudioAdapter::Close()

  1554. {

  1555. #ifdef JACK_MONITOR

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

  1557. #endif

  1558.     AudioOutputUnitStop(fAUHAL);

  1559.     DisposeBuffers();

  1560.     CloseAUHAL();

  1561.     RemoveListeners();

  1562.     if (fPluginID > 0) {

  1563.         DestroyAggregateDevice();

  1564.     }

  1565.     return 0;

  1566. }

  1567. 

  1568. int JackCoreAudioAdapter::SetSampleRate(jack_nframes_t sample_rate)

  1569. {

  1570.     JackAudioAdapterInterface::SetHostSampleRate(sample_rate);

  1571.     Close();

  1572.     return Open();

  1573. }

  1574. 

  1575. int JackCoreAudioAdapter::SetBufferSize(jack_nframes_t buffer_size)

  1576. {

  1577.     JackAudioAdapterInterface::SetHostBufferSize(buffer_size);

  1578.     Close();

  1579.     return Open();

  1580. }

  1581. 

  1582. OSStatus JackCoreAudioAdapter::GetStreamLatencies(AudioDeviceID device, bool isInput, vector<int>& latencies)

  1583. {

  1584.     OSStatus err = noErr;

  1585.     UInt32 outSize1, outSize2, outSize3;

  1586.     Boolean	outWritable;

  1587. 

  1588.     err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreams, &outSize1, &outWritable);

  1589.     if (err == noErr) {

  1590.         int stream_count = outSize1 / sizeof(UInt32);

  1591.         AudioStreamID streamIDs[stream_count];

  1592.         AudioBufferList bufferList[stream_count];

  1593.         UInt32 streamLatency;

  1594.         outSize2 = sizeof(UInt32);

  1595. 

  1596.         err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreams, &outSize1, streamIDs);

  1597.         if (err != noErr) {

  1598.             jack_error("GetStreamLatencies kAudioDevicePropertyStreams err = %d", err);

  1599.             return err;

  1600.         }

  1601. 

  1602.         err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize3, &outWritable);

  1603.         if (err != noErr) {

  1604.             jack_error("GetStreamLatencies kAudioDevicePropertyStreamConfiguration err = %d", err);

  1605.             return err;

  1606.         }

  1607. 

  1608.         for (int i = 0; i < stream_count; i++) {

  1609.             err = AudioStreamGetProperty(streamIDs[i], 0, kAudioStreamPropertyLatency, &outSize2, &streamLatency);

  1610.             if (err != noErr) {

  1611.                 jack_error("GetStreamLatencies kAudioStreamPropertyLatency err = %d", err);

  1612.                 return err;

  1613.             }

  1614.             err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize3, bufferList);

  1615.             if (err != noErr) {

  1616.                 jack_error("GetStreamLatencies kAudioDevicePropertyStreamConfiguration err = %d", err);

  1617.                 return err;

  1618.             }

  1619.             // Push 'channel' time the stream latency

  1620.             for (uint k = 0; k < bufferList->mBuffers[i].mNumberChannels; k++) {

  1621.                 latencies.push_back(streamLatency);

  1622.             }

  1623.         }

  1624.     }

  1625.     return err;

  1626. }

  1627. 

  1628. int JackCoreAudioAdapter::GetLatency(int port_index, bool input)

  1629. {

  1630.     UInt32 size = sizeof(UInt32);

  1631.     UInt32 value1 = 0;

  1632.     UInt32 value2 = 0;

  1633. 

  1634.     OSStatus err = AudioDeviceGetProperty(fDeviceID, 0, input, kAudioDevicePropertyLatency, &size, &value1);

  1635.     if (err != noErr) {

  1636.         jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error");

  1637.     }

  1638.     err = AudioDeviceGetProperty(fDeviceID, 0, input, kAudioDevicePropertySafetyOffset, &size, &value2);

  1639.     if (err != noErr) {

  1640.         jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");

  1641.     }

  1642. 

  1643.     // TODO : add stream latency

  1644. 

  1645.     return value1 + value2 + fAdaptedBufferSize;

  1646. }

  1647. 

  1648. int JackCoreAudioAdapter::GetInputLatency(int port_index)

  1649. {

  1650.     if (port_index < int(fInputLatencies.size())) {

  1651.         return GetLatency(port_index, true) + fInputLatencies[port_index];

  1652.     } else {

  1653.         // No stream latency

  1654.         return GetLatency(port_index, true);

  1655.     }

  1656. }

  1657. 

  1658. int JackCoreAudioAdapter::GetOutputLatency(int port_index)

  1659. {

  1660.     if (port_index < int(fOutputLatencies.size())) {

  1661.         return GetLatency(port_index, false) + fOutputLatencies[port_index];

  1662.     } else {

  1663.         // No stream latency

  1664.         return GetLatency(port_index, false);

  1665.     }

  1666. }

  1667. 

  1668. } // namespace

  1669. 

  1670. #ifdef __cplusplus

  1671. extern "C"

  1672. {

  1673. #endif

  1674. 

  1675.    SERVER_EXPORT jack_driver_desc_t* jack_get_descriptor()

  1676.    {

  1677.         jack_driver_desc_t * desc;

  1678.         jack_driver_desc_filler_t filler;

  1679.         jack_driver_param_value_t value;

  1680. 

  1681.         desc = jack_driver_descriptor_construct("audioadapter", JackDriverNone, "netjack audio <==> net backend adapter", &filler);

  1682. 

  1683.         value.i = -1;

  1684.         jack_driver_descriptor_add_parameter(desc, &filler, "channels", 'c', JackDriverParamInt, &value, NULL, "Maximum number of channels", "Maximum number of channels. If -1, max possible number of channels will be used");

  1685.         jack_driver_descriptor_add_parameter(desc, &filler, "in-channels", 'i', JackDriverParamInt, &value, NULL, "Maximum number of input channels", "Maximum number of input channels. If -1, max possible number of input channels will be used");

  1686.         jack_driver_descriptor_add_parameter(desc, &filler, "out-channels", 'o', JackDriverParamInt, &value, NULL, "Maximum number of output channels", "Maximum number of output channels. If -1, max possible number of output channels will be used");

  1687. 

  1688.         value.str[0] = 0;

  1689.         jack_driver_descriptor_add_parameter(desc, &filler, "capture", 'C', JackDriverParamString, &value, NULL, "Input CoreAudio device name", NULL);

  1690.         jack_driver_descriptor_add_parameter(desc, &filler, "playback", 'P', JackDriverParamString, &value, NULL, "Output CoreAudio device name", NULL);

  1691. 

  1692.         value.ui = 44100U;

  1693.         jack_driver_descriptor_add_parameter(desc, &filler, "rate", 'r', JackDriverParamUInt, &value, NULL, "Sample rate", NULL);

  1694. 

  1695.         value.ui = 512U;

  1696.         jack_driver_descriptor_add_parameter(desc, &filler, "period", 'p', JackDriverParamUInt, &value, NULL, "Frames per period", NULL);

  1697. 

  1698.         value.i = TRUE;

  1699.         jack_driver_descriptor_add_parameter(desc, &filler, "duplex", 'D', JackDriverParamBool, &value, NULL, "Provide both capture and playback ports", NULL);

  1700. 

  1701.         value.str[0] = 0;

  1702.         jack_driver_descriptor_add_parameter(desc, &filler, "device", 'd', JackDriverParamString, &value, NULL, "CoreAudio device name", NULL);

  1703. 

  1704.         value.i = TRUE;

  1705.         jack_driver_descriptor_add_parameter(desc, &filler, "list-devices", 'l', JackDriverParamBool, &value, NULL, "Display available CoreAudio devices", NULL);

  1706. 

  1707.         value.ui = 0;

  1708.         jack_driver_descriptor_add_parameter(desc, &filler, "quality", 'q', JackDriverParamInt, &value, NULL, "Resample algorithm quality (0 - 4)", NULL);

  1709. 

  1710.         value.ui = 32768;

  1711.         jack_driver_descriptor_add_parameter(desc, &filler, "ring-buffer", 'g', JackDriverParamInt, &value, NULL, "Fixed ringbuffer size", "Fixed ringbuffer size (if not set => automatic adaptative)");

  1712. 

  1713.         value.i = FALSE;

  1714.         jack_driver_descriptor_add_parameter(desc, &filler, "clock-drift", 's', JackDriverParamBool, &value, NULL, "Clock drift compensation", "Whether to compensate clock drift in dynamically created aggregate device");

  1715. 

  1716.         return desc;

  1717.     }

  1718. 

  1719. 

  1720. #ifdef __cplusplus

  1721. }

  1722. #endif