macosx/coreaudio/JackCoreAudioAdapter.mm

   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::AudioHardwareNotificationCallback(AudioHardwarePropertyID inPropertyID, void* inClientData)
 165 {
 166     JackCoreAudioAdapter* driver = (JackCoreAudioAdapter*)inClientData;
 167
 168     switch (inPropertyID) {
 169
 170         case kAudioHardwarePropertyDevices: {
 171             jack_log("JackCoreAudioAdapter::AudioHardwareNotificationCallback kAudioHardwarePropertyDevices");
 172             DisplayDeviceNames();
 173             break;
 174         }
 175     }
 176
 177     return noErr;
 178 }
 179
 180 OSStatus JackCoreAudioAdapter::SRNotificationCallback(AudioDeviceID inDevice,
 181                                                         UInt32 inChannel,
 182                                                         Boolean isInput,
 183                                                         AudioDevicePropertyID inPropertyID,
 184                                                         void* inClientData)
 185 {
 186     JackCoreAudioAdapter* driver = static_cast<JackCoreAudioAdapter*>(inClientData);
 187
 188     switch (inPropertyID) {
 189
 190         case kAudioDevicePropertyNominalSampleRate: {
 191             jack_log("JackCoreAudioAdapter::SRNotificationCallback kAudioDevicePropertyNominalSampleRate");
 192             driver->fState = true;
 193             break;
 194         }
 195     }
 196
 197     return noErr;
 198 }
 199
 200 // A better implementation would try to recover in case of hardware device change (see HALLAB HLFilePlayerWindowControllerAudioDevicePropertyListenerProc code)
 201 OSStatus JackCoreAudioAdapter::DeviceNotificationCallback(AudioDeviceID inDevice,
 202         UInt32 inChannel,
 203         Boolean isInput,
 204         AudioDevicePropertyID inPropertyID,
 205         void* inClientData)
 206 {
 207
 208     switch (inPropertyID) {
 209
 210         case kAudioDeviceProcessorOverload: {
 211             jack_error("JackCoreAudioAdapter::DeviceNotificationCallback kAudioDeviceProcessorOverload");
 212             break;
 213                 }
 214
 215         case kAudioDevicePropertyStreamConfiguration: {
 216             jack_error("Cannot handle kAudioDevicePropertyStreamConfiguration");
 217             return kAudioHardwareUnsupportedOperationError;
 218         }
 219
 220         case kAudioDevicePropertyNominalSampleRate: {
 221             jack_error("Cannot handle kAudioDevicePropertyNominalSampleRate");
 222             return kAudioHardwareUnsupportedOperationError;
 223         }
 224
 225     }
 226     return noErr;
 227 }
 228
 229 int JackCoreAudioAdapter::AddListeners()
 230 {
 231     OSStatus err = noErr;
 232
 233     // Add listeners
 234     err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDeviceProcessorOverload, DeviceNotificationCallback, this);
 235     if (err != noErr) {
 236         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDeviceProcessorOverload");
 237         printError(err);
 238         return -1;
 239     }
 240
 241     err = AudioHardwareAddPropertyListener(kAudioHardwarePropertyDevices, AudioHardwareNotificationCallback, this);
 242     if (err != noErr) {
 243         jack_error("Error calling AudioHardwareAddPropertyListener with kAudioHardwarePropertyDevices");
 244         printError(err);
 245         return -1;
 246     }
 247
 248     err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, DeviceNotificationCallback, this);
 249     if (err != noErr) {
 250         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyNominalSampleRate");
 251         printError(err);
 252         return -1;
 253     }
 254
 255     err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyDeviceIsRunning, DeviceNotificationCallback, this);
 256     if (err != noErr) {
 257         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyDeviceIsRunning");
 258         printError(err);
 259         return -1;
 260     }
 261
 262     err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyStreamConfiguration, DeviceNotificationCallback, this);
 263     if (err != noErr) {
 264         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyStreamConfiguration");
 265         printError(err);
 266         return -1;
 267     }
 268
 269     err = AudioDeviceAddPropertyListener(fDeviceID, 0, false, kAudioDevicePropertyStreamConfiguration, DeviceNotificationCallback, this);
 270     if (err != noErr) {
 271         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyStreamConfiguration");
 272         printError(err);
 273         return -1;
 274     }
 275
 276     return 0;
 277 }
 278
 279 void JackCoreAudioAdapter::RemoveListeners()
 280 {
 281     AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDeviceProcessorOverload, DeviceNotificationCallback);
 282     AudioHardwareRemovePropertyListener(kAudioHardwarePropertyDevices, AudioHardwareNotificationCallback);
 283     AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, DeviceNotificationCallback);
 284     AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyDeviceIsRunning, DeviceNotificationCallback);
 285     AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyStreamConfiguration, DeviceNotificationCallback);
 286     AudioDeviceRemovePropertyListener(fDeviceID, 0, false, kAudioDevicePropertyStreamConfiguration, DeviceNotificationCallback);
 287 }
 288
 289 OSStatus JackCoreAudioAdapter::Render(void *inRefCon,
 290                                     AudioUnitRenderActionFlags *ioActionFlags,
 291                                     const AudioTimeStamp *inTimeStamp,
 292                                     UInt32 inBusNumber,
 293                                     UInt32 inNumberFrames,
 294                                     AudioBufferList *ioData)
 295 {
 296     return static_cast<JackCoreAudioAdapter*>(inRefCon)->Render(ioActionFlags, inTimeStamp, inNumberFrames, ioData);
 297 }
 298
 299 OSStatus JackCoreAudioAdapter::Render(AudioUnitRenderActionFlags *ioActionFlags,
 300                                     const AudioTimeStamp *inTimeStamp,
 301                                     UInt32 inNumberFrames,
 302                                     AudioBufferList *ioData)
 303 {
 304     OSStatus err = AudioUnitRender(fAUHAL, ioActionFlags, inTimeStamp, 1, inNumberFrames, fInputData);
 305
 306     if (err == noErr) {
 307         jack_default_audio_sample_t* inputBuffer[fCaptureChannels];
 308         jack_default_audio_sample_t* outputBuffer[fPlaybackChannels];
 309
 310         for (int i = 0; i < fCaptureChannels; i++) {
 311             inputBuffer[i] = (jack_default_audio_sample_t*)fInputData->mBuffers[i].mData;
 312         }
 313         for (int i = 0; i < fPlaybackChannels; i++) {
 314             outputBuffer[i] = (jack_default_audio_sample_t*)ioData->mBuffers[i].mData;
 315         }
 316
 317         PushAndPull((jack_default_audio_sample_t**)inputBuffer, (jack_default_audio_sample_t**)outputBuffer, inNumberFrames);
 318         return noErr;
 319     } else {
 320         return err;
 321     }
 322 }
 323
 324 JackCoreAudioAdapter::JackCoreAudioAdapter(jack_nframes_t buffer_size, jack_nframes_t sample_rate, const JSList* params)
 325                 :JackAudioAdapterInterface(buffer_size, sample_rate), fInputData(0), fCapturing(false), fPlaying(false), fState(false)
 326 {
 327     const JSList* node;
 328     const jack_driver_param_t* param;
 329     int in_nChannels = 0;
 330     int out_nChannels = 0;
 331     char captureName[256];
 332     char playbackName[256];
 333     fCaptureUID[0] = 0;
 334     fPlaybackUID[0] = 0;
 335     fClockDriftCompensate = false;
 336
 337     // Default values
 338     fCaptureChannels = -1;
 339     fPlaybackChannels = -1;
 340
 341     SInt32 major;
 342     SInt32 minor;
 343     Gestalt(gestaltSystemVersionMajor, &major);
 344     Gestalt(gestaltSystemVersionMinor, &minor);
 345
 346     // Starting with 10.6 systems, the HAL notification thread is created internally
 347     if (major == 10 && minor >= 6) {
 348         CFRunLoopRef theRunLoop = NULL;
 349         AudioObjectPropertyAddress theAddress = { kAudioHardwarePropertyRunLoop, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
 350         OSStatus theError = AudioObjectSetPropertyData (kAudioObjectSystemObject, &theAddress, 0, NULL, sizeof(CFRunLoopRef), &theRunLoop);
 351         if (theError != noErr) {
 352             jack_error("JackCoreAudioAdapter::Open kAudioHardwarePropertyRunLoop error");
 353         }
 354     }
 355
 356     for (node = params; node; node = jack_slist_next(node)) {
 357         param = (const jack_driver_param_t*) node->data;
 358
 359         switch (param->character) {
 360
 361             case 'i':
 362                 fCaptureChannels = param->value.ui;
 363                 break;
 364
 365             case 'o':
 366                 fPlaybackChannels = param->value.ui;
 367                 break;
 368
 369             case 'C':
 370                 fCapturing = true;
 371                 strncpy(fCaptureUID, param->value.str, 256);
 372                 break;
 373
 374             case 'P':
 375                 fPlaying = true;
 376                 strncpy(fPlaybackUID, param->value.str, 256);
 377                 break;
 378
 379             case 'd':
 380                 strncpy(fCaptureUID, param->value.str, 256);
 381                 strncpy(fPlaybackUID, param->value.str, 256);
 382                 break;
 383
 384             case 'D':
 385                 fCapturing = fPlaying = true;
 386                 break;
 387
 388             case 'r':
 389                 SetAdaptedSampleRate(param->value.ui);
 390                 break;
 391
 392             case 'p':
 393                 SetAdaptedBufferSize(param->value.ui);
 394                 break;
 395
 396             case 'l':
 397                 DisplayDeviceNames();
 398                 break;
 399
 400             case 'q':
 401                 fQuality = param->value.ui;
 402                 break;
 403
 404             case 'g':
 405                 fRingbufferCurSize = param->value.ui;
 406                 fAdaptative = false;
 407                 break;
 408
 409             case 's':
 410                 fClockDriftCompensate = true;
 411                 break;
 412         }
 413     }
 414
 415     /* duplex is the default */
 416     if (!fCapturing && !fPlaying) {
 417         fCapturing = true;
 418         fPlaying = true;
 419     }
 420
 421     if (SetupDevices(fCaptureUID, fPlaybackUID, captureName, playbackName, fAdaptedSampleRate) < 0) {
 422        throw std::bad_alloc();
 423     }
 424
 425     if (SetupChannels(fCapturing, fPlaying, fCaptureChannels, fPlaybackChannels, in_nChannels, out_nChannels, true) < 0) {
 426         throw std::bad_alloc();
 427     }
 428
 429     if (SetupBufferSize(fAdaptedBufferSize) < 0) {
 430         throw std::bad_alloc();
 431     }
 432
 433     if (SetupSampleRate(fAdaptedSampleRate) < 0) {
 434         throw std::bad_alloc();
 435     }
 436
 437     if (OpenAUHAL(fCapturing, fPlaying, fCaptureChannels, fPlaybackChannels, in_nChannels, out_nChannels, fAdaptedBufferSize, fAdaptedSampleRate) < 0) {
 438         throw std::bad_alloc();
 439     }
 440
 441     if (fCapturing && fCaptureChannels > 0) {
 442         if (SetupBuffers(fCaptureChannels) < 0) {
 443             throw std::bad_alloc();
 444         }
 445     }
 446
 447     if (AddListeners() < 0) {
 448         throw std::bad_alloc();
 449     }
 450
 451     GetStreamLatencies(fDeviceID, true, fInputLatencies);
 452     GetStreamLatencies(fDeviceID, false, fOutputLatencies);
 453 }
 454
 455 OSStatus JackCoreAudioAdapter::GetDefaultDevice(AudioDeviceID* id)
 456 {
 457     OSStatus res;
 458     UInt32 theSize = sizeof(UInt32);
 459     AudioDeviceID inDefault;
 460     AudioDeviceID outDefault;
 461
 462     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &theSize, &inDefault)) != noErr) {
 463         return res;
 464     }
 465
 466     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &theSize, &outDefault)) != noErr) {
 467         return res;
 468     }
 469
 470     jack_log("GetDefaultDevice: input = %ld output = %ld", inDefault, outDefault);
 471
 472     // Get the device only if default input and output are the same
 473     if (inDefault != outDefault) {
 474         jack_error("Default input and output devices are not the same !!");
 475         return kAudioHardwareBadDeviceError;
 476     } else if (inDefault == 0) {
 477         jack_error("Default input and output devices are null !!");
 478         return kAudioHardwareBadDeviceError;
 479     } else {
 480         *id = inDefault;
 481         return noErr;
 482     }
 483 }
 484
 485 OSStatus JackCoreAudioAdapter::GetTotalChannels(AudioDeviceID device, int& channelCount, bool isInput)
 486 {
 487     OSStatus err = noErr;
 488     UInt32      outSize;
 489     Boolean     outWritable;
 490
 491     channelCount = 0;
 492     err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize, &outWritable);
 493     if (err == noErr) {
 494         AudioBufferList bufferList[outSize];
 495         err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize, bufferList);
 496         if (err == noErr) {
 497             for (unsigned int i = 0; i < bufferList->mNumberBuffers; i++) {
 498                 channelCount += bufferList->mBuffers[i].mNumberChannels;
 499             }
 500         }
 501     }
 502
 503     return err;
 504 }
 505
 506 OSStatus JackCoreAudioAdapter::GetDeviceIDFromUID(const char* UID, AudioDeviceID* id)
 507 {
 508     UInt32 size = sizeof(AudioValueTranslation);
 509     CFStringRef inIUD = CFStringCreateWithCString(NULL, UID, CFStringGetSystemEncoding());
 510     AudioValueTranslation value = { &inIUD, sizeof(CFStringRef), id, sizeof(AudioDeviceID) };
 511
 512     if (inIUD == NULL) {
 513         return kAudioHardwareUnspecifiedError;
 514     } else {
 515         OSStatus res = AudioHardwareGetProperty(kAudioHardwarePropertyDeviceForUID, &size, &value);
 516         CFRelease(inIUD);
 517         jack_log("GetDeviceIDFromUID %s %ld", UID, *id);
 518         return (*id == kAudioDeviceUnknown) ? kAudioHardwareBadDeviceError : res;
 519     }
 520 }
 521
 522 OSStatus JackCoreAudioAdapter::GetDefaultInputDevice(AudioDeviceID* id)
 523 {
 524     OSStatus res;
 525     UInt32 theSize = sizeof(UInt32);
 526     AudioDeviceID inDefault;
 527
 528     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &theSize, &inDefault)) != noErr) {
 529         return res;
 530     }
 531
 532     if (inDefault == 0) {
 533         jack_error("Error: default input device is 0, please select a correct one !!");
 534         return -1;
 535     }
 536     jack_log("GetDefaultInputDevice: input = %ld ", inDefault);
 537     *id = inDefault;
 538     return noErr;
 539 }
 540
 541 OSStatus JackCoreAudioAdapter::GetDefaultOutputDevice(AudioDeviceID* id)
 542 {
 543     OSStatus res;
 544     UInt32 theSize = sizeof(UInt32);
 545     AudioDeviceID outDefault;
 546
 547     if ((res = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &theSize, &outDefault)) != noErr) {
 548         return res;
 549     }
 550
 551     if (outDefault == 0) {
 552         jack_error("Error: default output device is 0, please select a correct one !!");
 553         return -1;
 554     }
 555     jack_log("GetDefaultOutputDevice: output = %ld", outDefault);
 556     *id = outDefault;
 557     return noErr;
 558 }
 559
 560 OSStatus JackCoreAudioAdapter::GetDeviceNameFromID(AudioDeviceID id, char* name)
 561 {
 562     UInt32 size = 256;
 563     return AudioDeviceGetProperty(id, 0, false, kAudioDevicePropertyDeviceName, &size, name);
 564 }
 565
 566 AudioDeviceID JackCoreAudioAdapter::GetDeviceIDFromName(const char* name)
 567 {
 568     UInt32 size;
 569     Boolean isWritable;
 570     int i, deviceNum;
 571
 572     OSStatus err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size, &isWritable);
 573     if (err != noErr) {
 574         return -1;
 575     }
 576
 577     deviceNum = size / sizeof(AudioDeviceID);
 578     AudioDeviceID devices[deviceNum];
 579
 580     err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &size, devices);
 581     if (err != noErr) {
 582         return err;
 583     }
 584
 585     for (i = 0; i < deviceNum; i++) {
 586         char device_name[256];
 587         size = 256;
 588         err = AudioDeviceGetProperty(devices[i], 0, false, kAudioDevicePropertyDeviceName, &size, device_name);
 589         if (err != noErr) {
 590             return -1;
 591         } else if (strcmp(device_name, name) == 0) {
 592             return devices[i];
 593         }
 594     }
 595
 596     return -1;
 597 }
 598
 599 // Setup
 600 int JackCoreAudioAdapter::SetupDevices(const char* capture_driver_uid,
 601                                         const char* playback_driver_uid,
 602                                         char* capture_driver_name,
 603                                         char* playback_driver_name,
 604                                         jack_nframes_t samplerate)
 605 {
 606     capture_driver_name[0] = 0;
 607     playback_driver_name[0] = 0;
 608
 609     // Duplex
 610     if (strcmp(capture_driver_uid, "") != 0 && strcmp(playback_driver_uid, "") != 0) {
 611         jack_log("JackCoreAudioDriver::Open duplex");
 612
 613         // Same device for capture and playback...
 614         if (strcmp(capture_driver_uid, playback_driver_uid) == 0)  {
 615
 616             if (GetDeviceIDFromUID(playback_driver_uid, &fDeviceID) != noErr) {
 617                 jack_log("Will take default in/out");
 618                 if (GetDefaultDevice(&fDeviceID) != noErr) {
 619                     jack_error("Cannot open default device");
 620                     return -1;
 621                 }
 622             }
 623             if (GetDeviceNameFromID(fDeviceID, capture_driver_name) != noErr || GetDeviceNameFromID(fDeviceID, playback_driver_name) != noErr) {
 624                 jack_error("Cannot get device name from device ID");
 625                 return -1;
 626             }
 627
 628         } else {
 629
 630             // Creates aggregate device
 631             AudioDeviceID captureID, playbackID;
 632
 633             if (GetDeviceIDFromUID(capture_driver_uid, &captureID) != noErr) {
 634                 jack_log("Will take default input");
 635                 if (GetDefaultInputDevice(&captureID) != noErr) {
 636                     jack_error("Cannot open default input device");
 637                     return -1;
 638                 }
 639             }
 640
 641             if (GetDeviceIDFromUID(playback_driver_uid, &playbackID) != noErr) {
 642                 jack_log("Will take default output");
 643                 if (GetDefaultOutputDevice(&playbackID) != noErr) {
 644                     jack_error("Cannot open default output device");
 645                     return -1;
 646                 }
 647             }
 648
 649             if (CreateAggregateDevice(captureID, playbackID, samplerate, &fDeviceID) != noErr) {
 650                 return -1;
 651             }
 652         }
 653
 654     // Capture only
 655     } else if (strcmp(capture_driver_uid, "") != 0) {
 656         jack_log("JackCoreAudioAdapter::Open capture only");
 657         if (GetDeviceIDFromUID(capture_driver_uid, &fDeviceID) != noErr) {
 658             if (GetDefaultInputDevice(&fDeviceID) != noErr) {
 659                 jack_error("Cannot open default input device");
 660                 return -1;
 661             }
 662         }
 663         if (GetDeviceNameFromID(fDeviceID, capture_driver_name) != noErr) {
 664             jack_error("Cannot get device name from device ID");
 665             return -1;
 666         }
 667
 668     // Playback only
 669     } else if (strcmp(playback_driver_uid, "") != 0) {
 670         jack_log("JackCoreAudioAdapter::Open playback only");
 671         if (GetDeviceIDFromUID(playback_driver_uid, &fDeviceID) != noErr) {
 672             if (GetDefaultOutputDevice(&fDeviceID) != noErr) {
 673                 jack_error("Cannot open default output device");
 674                 return -1;
 675             }
 676         }
 677         if (GetDeviceNameFromID(fDeviceID, playback_driver_name) != noErr) {
 678             jack_error("Cannot get device name from device ID");
 679             return -1;
 680         }
 681
 682     // Use default driver in duplex mode
 683     } else {
 684         jack_log("JackCoreAudioAdapter::Open default driver");
 685         if (GetDefaultDevice(&fDeviceID) != noErr) {
 686             jack_error("Cannot open default device in duplex mode, so aggregate default input and default output");
 687
 688             // Creates aggregate device
 689             AudioDeviceID captureID = -1, playbackID = -1;
 690
 691             if (GetDeviceIDFromUID(capture_driver_uid, &captureID) != noErr) {
 692                 jack_log("Will take default input");
 693                 if (GetDefaultInputDevice(&captureID) != noErr) {
 694                     jack_error("Cannot open default input device");
 695                     goto built_in;
 696                 }
 697             }
 698
 699             if (GetDeviceIDFromUID(playback_driver_uid, &playbackID) != noErr) {
 700                 jack_log("Will take default output");
 701                 if (GetDefaultOutputDevice(&playbackID) != noErr) {
 702                     jack_error("Cannot open default output device");
 703                     goto built_in;
 704                 }
 705             }
 706
 707             if (captureID > 0 && playbackID > 0) {
 708                 if (CreateAggregateDevice(captureID, playbackID, samplerate, &fDeviceID) != noErr) {
 709                     goto built_in;
 710                 }
 711             } else {
 712                 jack_error("Cannot use default input/output");
 713                 goto built_in;
 714             }
 715         }
 716     }
 717
 718     return 0;
 719
 720 built_in:
 721
 722     // Aggregate built-in input and output
 723     AudioDeviceID captureID = GetDeviceIDFromName("Built-in Input");
 724     AudioDeviceID playbackID = GetDeviceIDFromName("Built-in Output");
 725
 726     if (captureID > 0 && playbackID > 0) {
 727         if (CreateAggregateDevice(captureID, playbackID, samplerate, &fDeviceID) != noErr) {
 728             return -1;
 729         }
 730     } else {
 731         jack_error("Cannot aggregate built-in input and output");
 732         return -1;
 733     }
 734
 735     return 0;
 736 }
 737
 738 int JackCoreAudioAdapter::SetupChannels(bool capturing,
 739                                         bool playing,
 740                                         int& inchannels,
 741                                         int& outchannels,
 742                                         int& in_nChannels,
 743                                         int& out_nChannels,
 744                                         bool strict)
 745 {
 746     OSStatus err = noErr;
 747
 748     if (capturing) {
 749         err = GetTotalChannels(fDeviceID, in_nChannels, true);
 750         if (err != noErr) {
 751             jack_error("Cannot get input channel number");
 752             printError(err);
 753             return -1;
 754         } else {
 755             jack_log("Max input channels : %d", in_nChannels);
 756         }
 757     }
 758
 759     if (playing) {
 760         err = GetTotalChannels(fDeviceID, out_nChannels, false);
 761         if (err != noErr) {
 762             jack_error("Cannot get output channel number");
 763             printError(err);
 764             return -1;
 765         } else {
 766             jack_log("Max output channels : %d", out_nChannels);
 767         }
 768     }
 769
 770     if (inchannels > in_nChannels) {
 771         jack_error("This device hasn't required input channels inchannels = %ld in_nChannels = %ld", inchannels, in_nChannels);
 772         if (strict) {
 773             return -1;
 774         }
 775     }
 776
 777     if (outchannels > out_nChannels) {
 778         jack_error("This device hasn't required output channels outchannels = %ld out_nChannels = %ld", outchannels, out_nChannels);
 779         if (strict) {
 780             return -1;
 781         }
 782     }
 783
 784     if (inchannels == -1) {
 785         jack_log("Setup max in channels = %ld", in_nChannels);
 786         inchannels = in_nChannels;
 787     }
 788
 789     if (outchannels == -1) {
 790         jack_log("Setup max out channels = %ld", out_nChannels);
 791         outchannels = out_nChannels;
 792     }
 793
 794     return 0;
 795 }
 796
 797 int JackCoreAudioAdapter::SetupBufferSize(jack_nframes_t buffer_size)
 798 {
 799     // Setting buffer size
 800     UInt32 outSize = sizeof(UInt32);
 801     OSStatus err = AudioDeviceSetProperty(fDeviceID, NULL, 0, false, kAudioDevicePropertyBufferFrameSize, outSize, &buffer_size);
 802     if (err != noErr) {
 803         jack_error("Cannot set buffer size %ld", buffer_size);
 804         printError(err);
 805         return -1;
 806     }
 807
 808     return 0;
 809 }
 810
 811 int JackCoreAudioAdapter::SetupSampleRate(jack_nframes_t samplerate)
 812 {
 813     return SetupSampleRateAux(fDeviceID, samplerate);
 814 }
 815
 816 int JackCoreAudioAdapter::SetupSampleRateAux(AudioDeviceID inDevice, jack_nframes_t samplerate)
 817 {
 818     OSStatus err = noErr;
 819     UInt32 outSize;
 820     Float64 sampleRate;
 821
 822     // Get sample rate
 823     outSize =  sizeof(Float64);
 824     err = AudioDeviceGetProperty(inDevice, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);
 825     if (err != noErr) {
 826         jack_error("Cannot get current sample rate");
 827         printError(err);
 828         return -1;
 829     } else {
 830         jack_log("Current sample rate = %f", sampleRate);
 831     }
 832
 833     // If needed, set new sample rate
 834     if (samplerate != (jack_nframes_t)sampleRate) {
 835         sampleRate = (Float64)samplerate;
 836
 837         // To get SR change notification
 838         err = AudioDeviceAddPropertyListener(inDevice, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback, this);
 839         if (err != noErr) {
 840             jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyNominalSampleRate");
 841             printError(err);
 842             return -1;
 843         }
 844         err = AudioDeviceSetProperty(inDevice, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, outSize, &sampleRate);
 845         if (err != noErr) {
 846             jack_error("Cannot set sample rate = %ld", samplerate);
 847             printError(err);
 848             return -1;
 849         }
 850
 851         // Waiting for SR change notification
 852         int count = 0;
 853         while (!fState && count++ < WAIT_COUNTER) {
 854             usleep(100000);
 855             jack_log("Wait count = %d", count);
 856         }
 857
 858         // Remove SR change notification
 859         AudioDeviceRemovePropertyListener(inDevice, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback);
 860     }
 861
 862     return 0;
 863 }
 864
 865 int JackCoreAudioAdapter::SetupBuffers(int inchannels)
 866 {
 867     jack_log("JackCoreAudioAdapter::SetupBuffers: input = %ld", inchannels);
 868
 869     // Prepare buffers
 870     fInputData = (AudioBufferList*)malloc(sizeof(UInt32) + inchannels * sizeof(AudioBuffer));
 871     fInputData->mNumberBuffers = inchannels;
 872     for (int i = 0; i < fCaptureChannels; i++) {
 873         fInputData->mBuffers[i].mNumberChannels = 1;
 874         fInputData->mBuffers[i].mDataByteSize = fAdaptedBufferSize * sizeof(jack_default_audio_sample_t);
 875         fInputData->mBuffers[i].mData = malloc(fAdaptedBufferSize * sizeof(jack_default_audio_sample_t));
 876     }
 877     return 0;
 878 }
 879
 880 void JackCoreAudioAdapter::DisposeBuffers()
 881 {
 882     if (fInputData) {
 883         for (int i = 0; i < fCaptureChannels; i++) {
 884             free(fInputData->mBuffers[i].mData);
 885         }
 886         free(fInputData);
 887         fInputData = 0;
 888     }
 889 }
 890
 891 int JackCoreAudioAdapter::OpenAUHAL(bool capturing,
 892                                    bool playing,
 893                                    int inchannels,
 894                                    int outchannels,
 895                                    int in_nChannels,
 896                                    int out_nChannels,
 897                                    jack_nframes_t buffer_size,
 898                                    jack_nframes_t samplerate)
 899 {
 900     ComponentResult err1;
 901     UInt32 enableIO;
 902     AudioStreamBasicDescription srcFormat, dstFormat;
 903     AudioDeviceID currAudioDeviceID;
 904     UInt32 size;
 905
 906     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);
 907
 908     if (inchannels == 0 && outchannels == 0) {
 909         jack_error("No input and output channels...");
 910         return -1;
 911     }
 912
 913     // AUHAL
 914 #if (defined(MAC_OS_X_VERSION_10_5) && (MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_5))
 915     AudioComponentDescription cd = {kAudioUnitType_Output, kAudioUnitSubType_HALOutput, kAudioUnitManufacturer_Apple, 0, 0};
 916     AudioComponent HALOutput = AudioComponentFindNext(NULL, &cd);
 917     err1 = AudioComponentInstanceNew(HALOutput, &fAUHAL);
 918     if (err1 != noErr) {
 919         jack_error("Error calling AudioComponentInstanceNew");
 920         printError(err1);
 921         goto error;
 922     }
 923 #else
 924     ComponentDescription cd = {kAudioUnitType_Output, kAudioUnitSubType_HALOutput, kAudioUnitManufacturer_Apple, 0, 0};
 925     Component HALOutput = FindNextComponent(NULL, &cd);
 926     err1 = OpenAComponent(HALOutput, &fAUHAL);
 927     if (err1 != noErr) {
 928         jack_error("Error calling OpenAComponent");
 929         printError(err1);
 930         goto error;
 931     }
 932 #endif
 933
 934     err1 = AudioUnitInitialize(fAUHAL);
 935     if (err1 != noErr) {
 936         jack_error("Cannot initialize AUHAL unit");
 937         printError(err1);
 938         goto error;
 939     }
 940
 941     // Start I/O
 942     if (capturing && inchannels > 0) {
 943         enableIO = 1;
 944         jack_log("Setup AUHAL input on");
 945     } else {
 946         enableIO = 0;
 947         jack_log("Setup AUHAL input off");
 948     }
 949
 950     err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &enableIO, sizeof(enableIO));
 951     if (err1 != noErr) {
 952         jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input");
 953         printError(err1);
 954         goto error;
 955     }
 956
 957     if (playing && outchannels > 0) {
 958         enableIO = 1;
 959         jack_log("Setup AUHAL output on");
 960     } else {
 961         enableIO = 0;
 962         jack_log("Setup AUHAL output off");
 963     }
 964
 965     err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &enableIO, sizeof(enableIO));
 966     if (err1 != noErr) {
 967         jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_EnableIO,kAudioUnitScope_Output");
 968         printError(err1);
 969         goto error;
 970     }
 971
 972     size = sizeof(AudioDeviceID);
 973     err1 = AudioUnitGetProperty(fAUHAL, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &currAudioDeviceID, &size);
 974     if (err1 != noErr) {
 975         jack_error("Error calling AudioUnitGetProperty - kAudioOutputUnitProperty_CurrentDevice");
 976         printError(err1);
 977         goto error;
 978     } else {
 979         jack_log("AudioUnitGetPropertyCurrentDevice = %d", currAudioDeviceID);
 980     }
 981
 982     // Setup up chosen device, in both input and output cases
 983     err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &fDeviceID, sizeof(AudioDeviceID));
 984     if (err1 != noErr) {
 985         jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_CurrentDevice");
 986         printError(err1);
 987         goto error;
 988     }
 989
 990     // Set buffer size
 991     if (capturing && inchannels > 0) {
 992         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 1, (UInt32*)&buffer_size, sizeof(UInt32));
 993         if (err1 != noErr) {
 994             jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_MaximumFramesPerSlice");
 995             printError(err1);
 996             goto error;
 997         }
 998     }
 999
1000     if (playing && outchannels > 0) {
1001         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0, (UInt32*)&buffer_size, sizeof(UInt32));
1002         if (err1 != noErr) {
1003             jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_MaximumFramesPerSlice");
1004             printError(err1);
1005             goto error;
1006         }
1007     }
1008
1009     // Setup channel map
1010     if (capturing && inchannels > 0 && inchannels <= in_nChannels) {
1011         SInt32 chanArr[in_nChannels];
1012         for (int i = 0; i < in_nChannels; i++) {
1013             chanArr[i] = -1;
1014         }
1015         for (int i = 0; i < inchannels; i++) {
1016             chanArr[i] = i;
1017         }
1018         AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_ChannelMap , kAudioUnitScope_Input, 1, chanArr, sizeof(SInt32) * in_nChannels);
1019         if (err1 != noErr) {
1020             jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap 1");
1021             printError(err1);
1022             goto error;
1023         }
1024     }
1025
1026     if (playing && outchannels > 0 && outchannels <= out_nChannels) {
1027         SInt32 chanArr[out_nChannels];
1028         for (int i = 0; i < out_nChannels; i++) {
1029             chanArr[i] = -1;
1030         }
1031         for (int i = 0; i < outchannels; i++) {
1032             chanArr[i] = i;
1033         }
1034         err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_ChannelMap, kAudioUnitScope_Output, 0, chanArr, sizeof(SInt32) * out_nChannels);
1035         if (err1 != noErr) {
1036             jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap 0");
1037             printError(err1);
1038             goto error;
1039         }
1040     }
1041
1042     // Setup stream converters
1043     if (capturing && inchannels > 0) {
1044
1045         size = sizeof(AudioStreamBasicDescription);
1046         err1 = AudioUnitGetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, &srcFormat, &size);
1047         if (err1 != noErr) {
1048             jack_error("Error calling AudioUnitGetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Input");
1049             printError(err1);
1050             goto error;
1051         }
1052         PrintStreamDesc(&srcFormat);
1053
1054         jack_log("Setup AUHAL input stream converter SR = %ld", samplerate);
1055         srcFormat.mSampleRate = samplerate;
1056         srcFormat.mFormatID = kAudioFormatLinearPCM;
1057         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;
1058         srcFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);
1059         srcFormat.mFramesPerPacket = 1;
1060         srcFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);
1061         srcFormat.mChannelsPerFrame = inchannels;
1062         srcFormat.mBitsPerChannel = 32;
1063         PrintStreamDesc(&srcFormat);
1064
1065         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &srcFormat, sizeof(AudioStreamBasicDescription));
1066
1067         if (err1 != noErr) {
1068             jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Input");
1069             printError(err1);
1070             goto error;
1071         }
1072     }
1073
1074     if (playing && outchannels > 0) {
1075
1076         size = sizeof(AudioStreamBasicDescription);
1077         err1 = AudioUnitGetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 1, &dstFormat, &size);
1078         if (err1 != noErr) {
1079             jack_error("Error calling AudioUnitGetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output");
1080             printError(err1);
1081             goto error;
1082         }
1083         PrintStreamDesc(&dstFormat);
1084
1085         jack_log("Setup AUHAL output stream converter SR = %ld", samplerate);
1086         dstFormat.mSampleRate = samplerate;
1087         dstFormat.mFormatID = kAudioFormatLinearPCM;
1088         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;
1089         dstFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);
1090         dstFormat.mFramesPerPacket = 1;
1091         dstFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);
1092         dstFormat.mChannelsPerFrame = outchannels;
1093         dstFormat.mBitsPerChannel = 32;
1094         PrintStreamDesc(&dstFormat);
1095
1096         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &dstFormat, sizeof(AudioStreamBasicDescription));
1097
1098         if (err1 != noErr) {
1099             jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_StreamFormat kAudioUnitScope_Output");
1100             printError(err1);
1101             goto error;
1102         }
1103     }
1104
1105     // Setup callbacks
1106     if (inchannels > 0 && outchannels == 0) {
1107         AURenderCallbackStruct output;
1108         output.inputProc = Render;
1109         output.inputProcRefCon = this;
1110         err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &output, sizeof(output));
1111         if (err1 != noErr) {
1112             jack_error("Error calling  AudioUnitSetProperty - kAudioUnitProperty_SetRenderCallback 1");
1113             printError(err1);
1114             goto error;
1115         }
1116     } else {
1117         AURenderCallbackStruct output;
1118         output.inputProc = Render;
1119         output.inputProcRefCon = this;
1120         err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &output, sizeof(output));
1121         if (err1 != noErr) {
1122             jack_error("Error calling AudioUnitSetProperty - kAudioUnitProperty_SetRenderCallback 0");
1123             printError(err1);
1124             goto error;
1125         }
1126     }
1127
1128     return 0;
1129
1130 error:
1131     CloseAUHAL();
1132     return -1;
1133 }
1134
1135 OSStatus JackCoreAudioAdapter::DestroyAggregateDevice()
1136 {
1137     OSStatus osErr = noErr;
1138     AudioObjectPropertyAddress pluginAOPA;
1139     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;
1140     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;
1141     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;
1142     UInt32 outDataSize;
1143
1144     osErr = AudioObjectGetPropertyDataSize(fPluginID, &pluginAOPA, 0, NULL, &outDataSize);
1145     if (osErr != noErr) {
1146         jack_error("JackCoreAudioAdapter::DestroyAggregateDevice : AudioObjectGetPropertyDataSize error");
1147         printError(osErr);
1148         return osErr;
1149     }
1150
1151     osErr = AudioObjectGetPropertyData(fPluginID, &pluginAOPA, 0, NULL, &outDataSize, &fDeviceID);
1152     if (osErr != noErr) {
1153         jack_error("JackCoreAudioAdapter::DestroyAggregateDevice : AudioObjectGetPropertyData error");
1154         printError(osErr);
1155         return osErr;
1156     }
1157
1158     return noErr;
1159 }
1160
1161 static CFStringRef GetDeviceName(AudioDeviceID id)
1162 {
1163     UInt32 size = sizeof(CFStringRef);
1164     CFStringRef UIname;
1165     OSStatus err = AudioDeviceGetProperty(id, 0, false, kAudioDevicePropertyDeviceUID, &size, &UIname);
1166     return (err == noErr) ? UIname : NULL;
1167 }
1168
1169 OSStatus JackCoreAudioAdapter::CreateAggregateDevice(AudioDeviceID captureDeviceID, AudioDeviceID playbackDeviceID, jack_nframes_t samplerate, AudioDeviceID* outAggregateDevice)
1170 {
1171     OSStatus err = noErr;
1172     AudioObjectID sub_device[32];
1173     UInt32 outSize = sizeof(sub_device);
1174
1175     err = AudioDeviceGetProperty(captureDeviceID, 0, kAudioDeviceSectionGlobal, kAudioAggregateDevicePropertyActiveSubDeviceList, &outSize, sub_device);
1176     vector<AudioDeviceID> captureDeviceIDArray;
1177
1178     if (err != noErr) {
1179         jack_log("Input device does not have subdevices");
1180         captureDeviceIDArray.push_back(captureDeviceID);
1181     } else {
1182         int num_devices = outSize / sizeof(AudioObjectID);
1183         jack_log("Input device has %d subdevices", num_devices);
1184         for (int i = 0; i < num_devices; i++) {
1185             captureDeviceIDArray.push_back(sub_device[i]);
1186         }
1187     }
1188
1189     outSize = sizeof(sub_device);
1190     err = AudioDeviceGetProperty(playbackDeviceID, 0, kAudioDeviceSectionGlobal, kAudioAggregateDevicePropertyActiveSubDeviceList, &outSize, sub_device);
1191     vector<AudioDeviceID> playbackDeviceIDArray;
1192
1193     if (err != noErr) {
1194         jack_log("Output device does not have subdevices");
1195         playbackDeviceIDArray.push_back(playbackDeviceID);
1196     } else {
1197         int num_devices = outSize / sizeof(AudioObjectID);
1198         jack_log("Output device has %d subdevices", num_devices);
1199         for (int i = 0; i < num_devices; i++) {
1200             playbackDeviceIDArray.push_back(sub_device[i]);
1201         }
1202     }
1203
1204     return CreateAggregateDeviceAux(captureDeviceIDArray, playbackDeviceIDArray, samplerate, outAggregateDevice);
1205 }
1206
1207 OSStatus JackCoreAudioAdapter::CreateAggregateDeviceAux(vector<AudioDeviceID> captureDeviceID, vector<AudioDeviceID> playbackDeviceID, jack_nframes_t samplerate, AudioDeviceID* outAggregateDevice)
1208 {
1209     OSStatus osErr = noErr;
1210     UInt32 outSize;
1211     Boolean outWritable;
1212
1213     // Prepare sub-devices for clock drift compensation
1214     // Workaround for bug in the HAL : until 10.6.2
1215     AudioObjectPropertyAddress theAddressOwned = { kAudioObjectPropertyOwnedObjects, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
1216     AudioObjectPropertyAddress theAddressDrift = { kAudioSubDevicePropertyDriftCompensation, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
1217     UInt32 theQualifierDataSize = sizeof(AudioObjectID);
1218     AudioClassID inClass = kAudioSubDeviceClassID;
1219     void* theQualifierData = &inClass;
1220     UInt32 subDevicesNum = 0;
1221
1222     //---------------------------------------------------------------------------
1223     // Setup SR of both devices otherwise creating AD may fail...
1224     //---------------------------------------------------------------------------
1225     UInt32 keptclockdomain = 0;
1226     UInt32 clockdomain = 0;
1227     outSize = sizeof(UInt32);
1228     bool need_clock_drift_compensation = false;
1229
1230     for (UInt32 i = 0; i < captureDeviceID.size(); i++) {
1231         if (SetupSampleRateAux(captureDeviceID[i], samplerate) < 0) {
1232             jack_error("JackCoreAudioAdapter::CreateAggregateDevice : cannot set SR of input device");
1233         } else  {
1234             // Check clock domain
1235             osErr = AudioDeviceGetProperty(captureDeviceID[i], 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyClockDomain, &outSize, &clockdomain);
1236             if (osErr != 0) {
1237                 jack_error("JackCoreAudioAdapter::CreateAggregateDevice : kAudioDevicePropertyClockDomain error");
1238                 printError(osErr);
1239             } else {
1240                 keptclockdomain = (keptclockdomain == 0) ? clockdomain : keptclockdomain;
1241                 jack_log("JackCoreAudioAdapter::CreateAggregateDevice : input clockdomain = %d", clockdomain);
1242                 if (clockdomain != 0 && clockdomain != keptclockdomain) {
1243                     jack_error("JackCoreAudioAdapter::CreateAggregateDevice : devices do not share the same clock!! clock drift compensation would be needed...");
1244                     need_clock_drift_compensation = true;
1245                 }
1246             }
1247         }
1248     }
1249
1250     for (UInt32 i = 0; i < playbackDeviceID.size(); i++) {
1251         if (SetupSampleRateAux(playbackDeviceID[i], samplerate) < 0) {
1252             jack_error("JackCoreAudioAdapter::CreateAggregateDevice : cannot set SR of output device");
1253         } else {
1254             // Check clock domain
1255             osErr = AudioDeviceGetProperty(playbackDeviceID[i], 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyClockDomain, &outSize, &clockdomain);
1256             if (osErr != 0) {
1257                 jack_error("JackCoreAudioAdapter::CreateAggregateDevice : kAudioDevicePropertyClockDomain error");
1258                 printError(osErr);
1259             } else {
1260                 keptclockdomain = (keptclockdomain == 0) ? clockdomain : keptclockdomain;
1261                 jack_log("JackCoreAudioAdapter::CreateAggregateDevice : output clockdomain = %d", clockdomain);
1262                 if (clockdomain != 0 && clockdomain != keptclockdomain) {
1263                     jack_error("JackCoreAudioAdapter::CreateAggregateDevice : devices do not share the same clock!! clock drift compensation would be needed...");
1264                     need_clock_drift_compensation = true;
1265                 }
1266             }
1267         }
1268     }
1269
1270     // If no valid clock domain was found, then assume we have to compensate...
1271     if (keptclockdomain == 0) {
1272         need_clock_drift_compensation = true;
1273     }
1274
1275     //---------------------------------------------------------------------------
1276     // Start to create a new aggregate by getting the base audio hardware plugin
1277     //---------------------------------------------------------------------------
1278
1279     char device_name[256];
1280     for (UInt32 i = 0; i < captureDeviceID.size(); i++) {
1281         GetDeviceNameFromID(captureDeviceID[i], device_name);
1282         jack_info("Separated input = '%s' ", device_name);
1283     }
1284
1285     for (UInt32 i = 0; i < playbackDeviceID.size(); i++) {
1286         GetDeviceNameFromID(playbackDeviceID[i], device_name);
1287         jack_info("Separated output = '%s' ", device_name);
1288     }
1289
1290     osErr = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyPlugInForBundleID, &outSize, &outWritable);
1291     if (osErr != noErr) {
1292         jack_error("JackCoreAudioAdapter::CreateAggregateDevice : AudioHardwareGetPropertyInfo kAudioHardwarePropertyPlugInForBundleID error");
1293         printError(osErr);
1294         return osErr;
1295     }
1296
1297     AudioValueTranslation pluginAVT;
1298
1299     CFStringRef inBundleRef = CFSTR("com.apple.audio.CoreAudio");
1300
1301     pluginAVT.mInputData = &inBundleRef;
1302     pluginAVT.mInputDataSize = sizeof(inBundleRef);
1303     pluginAVT.mOutputData = &fPluginID;
1304     pluginAVT.mOutputDataSize = sizeof(fPluginID);
1305
1306     osErr = AudioHardwareGetProperty(kAudioHardwarePropertyPlugInForBundleID, &outSize, &pluginAVT);
1307     if (osErr != noErr) {
1308         jack_error("JackCoreAudioAdapter::CreateAggregateDevice : AudioHardwareGetProperty kAudioHardwarePropertyPlugInForBundleID error");
1309         printError(osErr);
1310         return osErr;
1311     }
1312
1313     //-------------------------------------------------
1314     // Create a CFDictionary for our aggregate device
1315     //-------------------------------------------------
1316
1317     CFMutableDictionaryRef aggDeviceDict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
1318
1319     CFStringRef AggregateDeviceNameRef = CFSTR("JackDuplex");
1320     CFStringRef AggregateDeviceUIDRef = CFSTR("com.grame.JackDuplex");
1321
1322     // add the name of the device to the dictionary
1323     CFDictionaryAddValue(aggDeviceDict, CFSTR(kAudioAggregateDeviceNameKey), AggregateDeviceNameRef);
1324
1325     // add our choice of UID for the aggregate device to the dictionary
1326     CFDictionaryAddValue(aggDeviceDict, CFSTR(kAudioAggregateDeviceUIDKey), AggregateDeviceUIDRef);
1327
1328     // add a "private aggregate key" to the dictionary
1329     int value = 1;
1330     CFNumberRef AggregateDeviceNumberRef = CFNumberCreate(NULL, kCFNumberIntType, &value);
1331
1332     SInt32 system;
1333     Gestalt(gestaltSystemVersion, &system);
1334
1335     jack_log("JackCoreAudioAdapter::CreateAggregateDevice : system version = %x limit = %x", system, 0x00001054);
1336
1337     // Starting with 10.5.4 systems, the AD can be internal... (better)
1338     if (system < 0x00001054) {
1339         jack_log("JackCoreAudioAdapter::CreateAggregateDevice : public aggregate device....");
1340     } else {
1341         jack_log("JackCoreAudioAdapter::CreateAggregateDevice : private aggregate device....");
1342         CFDictionaryAddValue(aggDeviceDict, CFSTR(kAudioAggregateDeviceIsPrivateKey), AggregateDeviceNumberRef);
1343     }
1344
1345     // Prepare sub-devices for clock drift compensation
1346     CFMutableArrayRef subDevicesArrayClock = NULL;
1347
1348     /*
1349      if (fClockDriftCompensate) {
1350      if (need_clock_drift_compensation) {
1351      jack_info("Clock drift compensation activated...");
1352      subDevicesArrayClock = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
1353
1354      for (UInt32 i = 0; i < captureDeviceID.size(); i++) {
1355      CFStringRef UID = GetDeviceName(captureDeviceID[i]);
1356      if (UID) {
1357      CFMutableDictionaryRef subdeviceAggDeviceDict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
1358      CFDictionaryAddValue(subdeviceAggDeviceDict, CFSTR(kAudioSubDeviceUIDKey), UID);
1359      CFDictionaryAddValue(subdeviceAggDeviceDict, CFSTR(kAudioSubDeviceDriftCompensationKey), AggregateDeviceNumberRef);
1360      //CFRelease(UID);
1361      CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);
1362      }
1363      }
1364
1365      for (UInt32 i = 0; i < playbackDeviceID.size(); i++) {
1366      CFStringRef UID = GetDeviceName(playbackDeviceID[i]);
1367      if (UID) {
1368      CFMutableDictionaryRef subdeviceAggDeviceDict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
1369      CFDictionaryAddValue(subdeviceAggDeviceDict, CFSTR(kAudioSubDeviceUIDKey), UID);
1370      CFDictionaryAddValue(subdeviceAggDeviceDict, CFSTR(kAudioSubDeviceDriftCompensationKey), AggregateDeviceNumberRef);
1371      //CFRelease(UID);
1372      CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);
1373      }
1374      }
1375
1376      // add sub-device clock array for the aggregate device to the dictionary
1377      CFDictionaryAddValue(aggDeviceDict, CFSTR(kAudioAggregateDeviceSubDeviceListKey), subDevicesArrayClock);
1378      } else {
1379      jack_info("Clock drift compensation was asked but is not needed (devices use the same clock domain)");
1380      }
1381      }
1382      */
1383
1384     //-------------------------------------------------
1385     // Create a CFMutableArray for our sub-device list
1386     //-------------------------------------------------
1387
1388     // we need to append the UID for each device to a CFMutableArray, so create one here
1389     CFMutableArrayRef subDevicesArray = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
1390
1391     vector<CFStringRef> captureDeviceUID;
1392     for (UInt32 i = 0; i < captureDeviceID.size(); i++) {
1393         CFStringRef ref = GetDeviceName(captureDeviceID[i]);
1394         if (ref == NULL) {
1395             return -1;
1396         }
1397         captureDeviceUID.push_back(ref);
1398         // input sub-devices in this example, so append the sub-device's UID to the CFArray
1399         CFArrayAppendValue(subDevicesArray, ref);
1400     }
1401
1402     vector<CFStringRef> playbackDeviceUID;
1403     for (UInt32 i = 0; i < playbackDeviceID.size(); i++) {
1404         CFStringRef ref = GetDeviceName(playbackDeviceID[i]);
1405         if (ref == NULL) {
1406             return -1;
1407         }
1408         playbackDeviceUID.push_back(ref);
1409         // output sub-devices in this example, so append the sub-device's UID to the CFArray
1410         CFArrayAppendValue(subDevicesArray, ref);
1411     }
1412
1413     //-----------------------------------------------------------------------
1414     // Feed the dictionary to the plugin, to create a blank aggregate device
1415     //-----------------------------------------------------------------------
1416
1417     AudioObjectPropertyAddress pluginAOPA;
1418     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;
1419     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;
1420     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;
1421     UInt32 outDataSize;
1422
1423     osErr = AudioObjectGetPropertyDataSize(fPluginID, &pluginAOPA, 0, NULL, &outDataSize);
1424     if (osErr != noErr) {
1425         jack_error("JackCoreAudioAdapter::CreateAggregateDevice : AudioObjectGetPropertyDataSize error");
1426         printError(osErr);
1427         goto error;
1428     }
1429
1430     osErr = AudioObjectGetPropertyData(fPluginID, &pluginAOPA, sizeof(aggDeviceDict), &aggDeviceDict, &outDataSize, outAggregateDevice);
1431     if (osErr != noErr) {
1432         jack_error("JackCoreAudioAdapter::CreateAggregateDevice : AudioObjectGetPropertyData error");
1433         printError(osErr);
1434         goto error;
1435     }
1436
1437     // pause for a bit to make sure that everything completed correctly
1438     // this is to work around a bug in the HAL where a new aggregate device seems to disappear briefly after it is created
1439     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);
1440
1441     //-------------------------
1442     // Set the sub-device list
1443     //-------------------------
1444
1445     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;
1446     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;
1447     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;
1448     outDataSize = sizeof(CFMutableArrayRef);
1449     osErr = AudioObjectSetPropertyData(*outAggregateDevice, &pluginAOPA, 0, NULL, outDataSize, &subDevicesArray);
1450     if (osErr != noErr) {
1451         jack_error("JackCoreAudioAdapter::CreateAggregateDevice : AudioObjectSetPropertyData for sub-device list error");
1452         printError(osErr);
1453         goto error;
1454     }
1455
1456     // pause again to give the changes time to take effect
1457     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);
1458
1459     //-----------------------
1460     // Set the master device
1461     //-----------------------
1462
1463     // set the master device manually (this is the device which will act as the master clock for the aggregate device)
1464     // pass in the UID of the device you want to use
1465     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;
1466     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;
1467     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;
1468     outDataSize = sizeof(CFStringRef);
1469     osErr = AudioObjectSetPropertyData(*outAggregateDevice, &pluginAOPA, 0, NULL, outDataSize, &playbackDeviceUID[0]);  // First playback is master...
1470     if (osErr != noErr) {
1471         jack_error("JackCoreAudioAdapter::CreateAggregateDevice : AudioObjectSetPropertyData for master device error");
1472         printError(osErr);
1473         goto error;
1474     }
1475
1476     // pause again to give the changes time to take effect
1477     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);
1478
1479     // Prepare sub-devices for clock drift compensation
1480     // Workaround for bug in the HAL : until 10.6.2
1481
1482     if (fClockDriftCompensate) {
1483         if (need_clock_drift_compensation) {
1484             jack_info("Clock drift compensation activated...");
1485
1486             // Get the property data size
1487             osErr = AudioObjectGetPropertyDataSize(*outAggregateDevice, &theAddressOwned, theQualifierDataSize, theQualifierData, &outSize);
1488             if (osErr != noErr) {
1489                 jack_error("JackCoreAudioAdapter::CreateAggregateDevice kAudioObjectPropertyOwnedObjects error");
1490                 printError(osErr);
1491             }
1492
1493             //  Calculate the number of object IDs
1494             subDevicesNum = outSize / sizeof(AudioObjectID);
1495             jack_info("JackCoreAudioAdapter::CreateAggregateDevice clock drift compensation, number of sub-devices = %d", subDevicesNum);
1496             AudioObjectID subDevices[subDevicesNum];
1497             outSize = sizeof(subDevices);
1498
1499             osErr = AudioObjectGetPropertyData(*outAggregateDevice, &theAddressOwned, theQualifierDataSize, theQualifierData, &outSize, subDevices);
1500             if (osErr != noErr) {
1501                 jack_error("JackCoreAudioAdapter::CreateAggregateDevice kAudioObjectPropertyOwnedObjects error");
1502                 printError(osErr);
1503             }
1504
1505             // Set kAudioSubDevicePropertyDriftCompensation property...
1506             for (UInt32 index = 0; index < subDevicesNum; ++index) {
1507                 UInt32 theDriftCompensationValue = 1;
1508                 osErr = AudioObjectSetPropertyData(subDevices[index], &theAddressDrift, 0, NULL, sizeof(UInt32), &theDriftCompensationValue);
1509                 if (osErr != noErr) {
1510                     jack_error("JackCoreAudioAdapter::CreateAggregateDevice kAudioSubDevicePropertyDriftCompensation error");
1511                     printError(osErr);
1512                 }
1513             }
1514         } else {
1515             jack_info("Clock drift compensation was asked but is not needed (devices use the same clock domain)");
1516         }
1517     }
1518
1519     // pause again to give the changes time to take effect
1520     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);
1521
1522     //----------
1523     // Clean up
1524     //----------
1525
1526     // release the private AD key
1527     CFRelease(AggregateDeviceNumberRef);
1528
1529     // release the CF objects we have created - we don't need them any more
1530     CFRelease(aggDeviceDict);
1531     CFRelease(subDevicesArray);
1532
1533     if (subDevicesArrayClock) {
1534         CFRelease(subDevicesArrayClock);
1535     }
1536
1537     // release the device UID
1538     for (UInt32 i = 0; i < captureDeviceUID.size(); i++) {
1539         CFRelease(captureDeviceUID[i]);
1540     }
1541
1542     for (UInt32 i = 0; i < playbackDeviceUID.size(); i++) {
1543         CFRelease(playbackDeviceUID[i]);
1544     }
1545
1546     jack_log("New aggregate device %ld", *outAggregateDevice);
1547     return noErr;
1548
1549 error:
1550     DestroyAggregateDevice();
1551     return -1;
1552 }
1553
1554
1555 bool JackCoreAudioAdapter::IsAggregateDevice(AudioDeviceID device)
1556 {
1557     OSStatus err = noErr;
1558     AudioObjectID sub_device[32];
1559     UInt32 outSize = sizeof(sub_device);
1560     err = AudioDeviceGetProperty(device, 0, kAudioDeviceSectionGlobal, kAudioAggregateDevicePropertyActiveSubDeviceList, &outSize, sub_device);
1561
1562     if (err != noErr) {
1563         jack_log("Device does not have subdevices");
1564         return false;
1565     } else {
1566         int num_devices = outSize / sizeof(AudioObjectID);
1567         jack_log("Device does has %d subdevices", num_devices);
1568         return true;
1569     }
1570 }
1571
1572 void JackCoreAudioAdapter::CloseAUHAL()
1573 {
1574     AudioUnitUninitialize(fAUHAL);
1575     CloseComponent(fAUHAL);
1576 }
1577
1578 int JackCoreAudioAdapter::Open()
1579 {
1580     return (AudioOutputUnitStart(fAUHAL) != noErr)  ? -1 : 0;
1581 }
1582
1583 int JackCoreAudioAdapter::Close()
1584 {
1585 #ifdef JACK_MONITOR
1586     fTable.Save(fHostBufferSize, fHostSampleRate, fAdaptedSampleRate, fAdaptedBufferSize);
1587 #endif
1588     AudioOutputUnitStop(fAUHAL);
1589     DisposeBuffers();
1590     CloseAUHAL();
1591     RemoveListeners();
1592     if (fPluginID > 0) {
1593         DestroyAggregateDevice();
1594     }
1595     return 0;
1596 }
1597
1598 int JackCoreAudioAdapter::SetSampleRate(jack_nframes_t sample_rate)
1599 {
1600     JackAudioAdapterInterface::SetHostSampleRate(sample_rate);
1601     Close();
1602     return Open();
1603 }
1604
1605 int JackCoreAudioAdapter::SetBufferSize(jack_nframes_t buffer_size)
1606 {
1607     JackAudioAdapterInterface::SetHostBufferSize(buffer_size);
1608     Close();
1609     return Open();
1610 }
1611
1612 OSStatus JackCoreAudioAdapter::GetStreamLatencies(AudioDeviceID device, bool isInput, vector<int>& latencies)
1613 {
1614     OSStatus err = noErr;
1615     UInt32 outSize1, outSize2, outSize3;
1616     Boolean     outWritable;
1617
1618     err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreams, &outSize1, &outWritable);
1619     if (err == noErr) {
1620         int stream_count = outSize1 / sizeof(UInt32);
1621         AudioStreamID streamIDs[stream_count];
1622         AudioBufferList bufferList[stream_count];
1623         UInt32 streamLatency;
1624         outSize2 = sizeof(UInt32);
1625
1626         err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreams, &outSize1, streamIDs);
1627         if (err != noErr) {
1628             jack_error("GetStreamLatencies kAudioDevicePropertyStreams err = %d", err);
1629             return err;
1630         }
1631
1632         err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize3, &outWritable);
1633         if (err != noErr) {
1634             jack_error("GetStreamLatencies kAudioDevicePropertyStreamConfiguration err = %d", err);
1635             return err;
1636         }
1637
1638         for (int i = 0; i < stream_count; i++) {
1639             err = AudioStreamGetProperty(streamIDs[i], 0, kAudioStreamPropertyLatency, &outSize2, &streamLatency);
1640             if (err != noErr) {
1641                 jack_error("GetStreamLatencies kAudioStreamPropertyLatency err = %d", err);
1642                 return err;
1643             }
1644             err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize3, bufferList);
1645             if (err != noErr) {
1646                 jack_error("GetStreamLatencies kAudioDevicePropertyStreamConfiguration err = %d", err);
1647                 return err;
1648             }
1649             // Push 'channel' time the stream latency
1650             for (uint k = 0; k < bufferList->mBuffers[i].mNumberChannels; k++) {
1651                 latencies.push_back(streamLatency);
1652             }
1653         }
1654     }
1655     return err;
1656 }
1657
1658 int JackCoreAudioAdapter::GetLatency(int port_index, bool input)
1659 {
1660     UInt32 size = sizeof(UInt32);
1661     UInt32 value1 = 0;
1662     UInt32 value2 = 0;
1663
1664     OSStatus err = AudioDeviceGetProperty(fDeviceID, 0, input, kAudioDevicePropertyLatency, &size, &value1);
1665     if (err != noErr) {
1666         jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error");
1667     }
1668     err = AudioDeviceGetProperty(fDeviceID, 0, input, kAudioDevicePropertySafetyOffset, &size, &value2);
1669     if (err != noErr) {
1670         jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");
1671     }
1672
1673     // TODO : add stream latency
1674
1675     return value1 + value2 + fAdaptedBufferSize;
1676 }
1677
1678 int JackCoreAudioAdapter::GetInputLatency(int port_index)
1679 {
1680     if (port_index < int(fInputLatencies.size())) {
1681         return GetLatency(port_index, true) + fInputLatencies[port_index];
1682     } else {
1683         // No stream latency
1684         return GetLatency(port_index, true);
1685     }
1686 }
1687
1688 int JackCoreAudioAdapter::GetOutputLatency(int port_index)
1689 {
1690     if (port_index < int(fOutputLatencies.size())) {
1691         return GetLatency(port_index, false) + fOutputLatencies[port_index];
1692     } else {
1693         // No stream latency
1694         return GetLatency(port_index, false);
1695     }
1696 }
1697
1698 } // namespace
1699
1700 #ifdef __cplusplus
1701 extern "C"
1702 {
1703 #endif
1704
1705    SERVER_EXPORT jack_driver_desc_t* jack_get_descriptor()
1706    {
1707         jack_driver_desc_t * desc;
1708         jack_driver_desc_filler_t filler;
1709         jack_driver_param_value_t value;
1710
1711         desc = jack_driver_descriptor_construct("audioadapter", JackDriverNone, "netjack audio <==> net backend adapter", &filler);
1712
1713         value.i = -1;
1714         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");
1715         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");
1716
1717         value.str[0] = 0;
1718         jack_driver_descriptor_add_parameter(desc, &filler, "capture", 'C', JackDriverParamString, &value, NULL, "Input CoreAudio device name", NULL);
1719         jack_driver_descriptor_add_parameter(desc, &filler, "playback", 'P', JackDriverParamString, &value, NULL, "Output CoreAudio device name", NULL);
1720
1721         value.ui = 44100U;
1722         jack_driver_descriptor_add_parameter(desc, &filler, "rate", 'r', JackDriverParamUInt, &value, NULL, "Sample rate", NULL);
1723
1724         value.ui = 512U;
1725         jack_driver_descriptor_add_parameter(desc, &filler, "period", 'p', JackDriverParamUInt, &value, NULL, "Frames per period", NULL);
1726
1727         value.i = true;
1728         jack_driver_descriptor_add_parameter(desc, &filler, "duplex", 'D', JackDriverParamBool, &value, NULL, "Provide both capture and playback ports", NULL);
1729
1730         value.str[0] = 0;
1731         jack_driver_descriptor_add_parameter(desc, &filler, "device", 'd', JackDriverParamString, &value, NULL, "CoreAudio device name", NULL);
1732
1733         value.i = true;
1734         jack_driver_descriptor_add_parameter(desc, &filler, "list-devices", 'l', JackDriverParamBool, &value, NULL, "Display available CoreAudio devices", NULL);
1735
1736         value.ui = 0;
1737         jack_driver_descriptor_add_parameter(desc, &filler, "quality", 'q', JackDriverParamInt, &value, NULL, "Resample algorithm quality (0 - 4)", NULL);
1738
1739         value.ui = 32768;
1740         jack_driver_descriptor_add_parameter(desc, &filler, "ring-buffer", 'g', JackDriverParamInt, &value, NULL, "Fixed ringbuffer size", "Fixed ringbuffer size (if not set => automatic adaptative)");
1741
1742         value.i = false;
1743         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");
1744
1745         value.i = false;
1746         jack_driver_descriptor_add_parameter(desc, &filler, "auto-connect", 'c', JackDriverParamBool, &value, NULL, "Auto connect audioadapter to system ports", NULL);
1747
1748         return desc;
1749     }
1750
1751
1752 #ifdef __cplusplus
1753 }
1754 #endif
1755