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

2076 lines
81KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2004-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 "JackCoreAudioDriver.h"

  21. #include "JackEngineControl.h"

  22. #include "JackMachThread.h"

  23. #include "JackGraphManager.h"

  24. #include "JackError.h"

  25. #include "JackClientControl.h"

  26. #include "JackDriverLoader.h"

  27. #include "JackGlobals.h"

  28. #include "JackTools.h"

  29. #include "JackCompilerDeps.h"

  30. 

  31. #include <iostream>

  32. #include <CoreServices/CoreServices.h>

  33. #include <CoreFoundation/CFNumber.h>

  34. 

  35. namespace Jack

  36. {

  37. 

  38. static void Print4CharCode(const char* msg, long c)

  39. {

  40.     UInt32 __4CC_number = (c);

  41.     char __4CC_string[5];

  42.     *((SInt32*)__4CC_string) = EndianU32_NtoB(__4CC_number);

  43.     __4CC_string[4] = 0;

  44.     jack_log("%s'%s'", (msg), __4CC_string);

  45. }

  46. 

  47. static void PrintStreamDesc(AudioStreamBasicDescription *inDesc)

  48. {

  49.     jack_log("- - - - - - - - - - - - - - - - - - - -");

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

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

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

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

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

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

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

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

  58.     jack_log("- - - - - - - - - - - - - - - - - - - -\n");

  59. }

  60. 

  61. static void printError(OSStatus err)

  62. {

  63.     switch (err) {

  64.         case kAudioHardwareNoError:

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

  66.             break;

  67.         case kAudioConverterErr_FormatNotSupported:

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

  69.             break;

  70.         case kAudioConverterErr_OperationNotSupported:

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

  72.             break;

  73.         case kAudioConverterErr_PropertyNotSupported:

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

  75.             break;

  76.         case kAudioConverterErr_InvalidInputSize:

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

  78.             break;

  79.         case kAudioConverterErr_InvalidOutputSize:

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

  81.             break;

  82.         case kAudioConverterErr_UnspecifiedError:

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

  84.             break;

  85.         case kAudioConverterErr_BadPropertySizeError:

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

  87.             break;

  88.         case kAudioConverterErr_RequiresPacketDescriptionsError:

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

  90.             break;

  91.         case kAudioConverterErr_InputSampleRateOutOfRange:

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

  93.             break;

  94.         case kAudioConverterErr_OutputSampleRateOutOfRange:

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

  96.             break;

  97.         case kAudioHardwareNotRunningError:

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

  99.             break;

  100.         case kAudioHardwareUnknownPropertyError:

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

  102.             break;

  103.         case kAudioHardwareIllegalOperationError:

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

  105.             break;

  106.         case kAudioHardwareBadDeviceError:

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

  108.             break;

  109.         case kAudioHardwareBadStreamError:

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

  111.             break;

  112.         case kAudioDeviceUnsupportedFormatError:

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

  114.             break;

  115.         case kAudioDevicePermissionsError:

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

  117.             break;

  118.         case kAudioHardwareBadObjectError:

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

  120.             break;

  121.         case kAudioHardwareUnsupportedOperationError:

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

  123.             break;

  124.         default:

  125.             Print4CharCode("error code : unknown", err);

  126.             break;

  127.     }

  128. }

  129. 

  130. static OSStatus DisplayDeviceNames()

  131. {

  132.     UInt32 size;

  133.     Boolean isWritable;

  134.     int i, deviceNum;

  135.     OSStatus err;

  136.     CFStringRef UIname;

  137. 

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

  139.     if (err != noErr)

  140.         return err;

  141. 

  142.     deviceNum = size / sizeof(AudioDeviceID);

  143.     AudioDeviceID devices[deviceNum];

  144. 

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

  146.     if (err != noErr)

  147.         return err;

  148. 

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

  150.         char device_name[256];

  151.         char internal_name[256];

  152. 

  153.         size = sizeof(CFStringRef);

  154.         UIname = NULL;

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

  156.         if (err == noErr) {

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

  158.         } else {

  159.             goto error;

  160.         }

  161. 

  162.         size = 256;

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

  164.         if (err != noErr)

  165.             return err;

  166. 

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

  168.     }

  169. 

  170.     return noErr;

  171. 

  172. error:

  173.     if (UIname != NULL)

  174.         CFRelease(UIname);

  175.     return err;

  176. }

  177. 

  178. static CFStringRef GetDeviceName(AudioDeviceID id)

  179. {

  180.     UInt32 size = sizeof(CFStringRef);

  181.     CFStringRef UIname;

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

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

  184. }

  185. 

  186. OSStatus JackCoreAudioDriver::Render(void *inRefCon,

  187.                                      AudioUnitRenderActionFlags *ioActionFlags,

  188.                                      const AudioTimeStamp *inTimeStamp,

  189.                                      UInt32 inBusNumber,

  190.                                      UInt32 inNumberFrames,

  191.                                      AudioBufferList *ioData)

  192. {

  193.     JackCoreAudioDriver* driver = (JackCoreAudioDriver*)inRefCon;

  194.     driver->fActionFags = ioActionFlags;

  195.     driver->fCurrentTime = (AudioTimeStamp *)inTimeStamp;

  196.     driver->fDriverOutputData = ioData;

  197. 

  198.     // Setup threadded based log function once...

  199.     if (set_threaded_log_function()) {

  200. 

  201.         jack_log("set_threaded_log_function");

  202.         JackMachThread::GetParams(pthread_self(), &driver->fEngineControl->fPeriod, &driver->fEngineControl->fComputation, &driver->fEngineControl->fConstraint);

  203. 

  204.         if (driver->fComputationGrain > 0) {

  205.             jack_log("JackCoreAudioDriver::Render : RT thread computation setup to %d percent of period", int(driver->fComputationGrain * 100));

  206.             driver->fEngineControl->fComputation = driver->fEngineControl->fPeriod * driver->fComputationGrain;

  207.         }

  208. 

  209.         // Signal waiting start function...

  210.         driver->fState = true;

  211.     }

  212. 

  213.     driver->CycleTakeBeginTime();

  214.     return driver->Process();

  215. }

  216. 

  217. int JackCoreAudioDriver::Read()

  218. {

  219.     OSStatus err = AudioUnitRender(fAUHAL, fActionFags, fCurrentTime, 1, fEngineControl->fBufferSize, fJackInputData);

  220.     return (err == noErr) ? 0 : -1;

  221. }

  222. 

  223. int JackCoreAudioDriver::Write()

  224. {

  225.     for (int i = 0; i < fPlaybackChannels; i++) {

  226.         if (fGraphManager->GetConnectionsNum(fPlaybackPortList[i]) > 0) {

  227.             jack_default_audio_sample_t* buffer = GetOutputBuffer(i);

  228.             int size = sizeof(jack_default_audio_sample_t) * fEngineControl->fBufferSize;

  229.             memcpy((jack_default_audio_sample_t*)fDriverOutputData->mBuffers[i].mData, buffer, size);

  230.             // Monitor ports

  231.             if (fWithMonitorPorts && fGraphManager->GetConnectionsNum(fMonitorPortList[i]) > 0)

  232.                 memcpy(GetMonitorBuffer(i), buffer, size);

  233.         } else {

  234.             memset((jack_default_audio_sample_t*)fDriverOutputData->mBuffers[i].mData, 0, sizeof(jack_default_audio_sample_t) * fEngineControl->fBufferSize);

  235.         }

  236.     }

  237.     return 0;

  238. }

  239. 

  240. 

  241. OSStatus JackCoreAudioDriver::SRNotificationCallback(AudioDeviceID inDevice,

  242.                                                     UInt32 inChannel,

  243.                                                     Boolean	isInput,

  244.                                                     AudioDevicePropertyID inPropertyID,

  245.                                                     void* inClientData)

  246. {

  247.     JackCoreAudioDriver* driver = (JackCoreAudioDriver*)inClientData;

  248. 

  249.     switch (inPropertyID) {

  250. 

  251.         case kAudioDevicePropertyNominalSampleRate: {

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

  253.             driver->fState = true;

  254.             // Check new sample rate

  255.             Float64 sampleRate;

  256.             UInt32 outSize =  sizeof(Float64);

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

  258.             if (err != noErr) {

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

  260.                 printError(err);

  261.             } else {

  262.                 jack_log("SRNotificationCallback : checked sample rate = %f", sampleRate);

  263.             }

  264.             break;

  265.         }

  266.     }

  267. 

  268.     return noErr;

  269. }

  270. 

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

  272. OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,

  273.                                                         UInt32 inChannel,

  274.                                                         Boolean	isInput,

  275.                                                         AudioDevicePropertyID inPropertyID,

  276.                                                         void* inClientData)

  277. {

  278.     JackCoreAudioDriver* driver = (JackCoreAudioDriver*)inClientData;

  279. 

  280.     switch (inPropertyID) {

  281. 

  282.         case kAudioDevicePropertyDeviceIsRunning: {

  283.             UInt32 isrunning = 0;

  284.             UInt32 outsize = sizeof(UInt32);

  285.             if (AudioDeviceGetProperty(driver->fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyDeviceIsRunning, &outsize, &isrunning) == noErr) {

  286.                 jack_log("JackCoreAudioDriver::DeviceNotificationCallback kAudioDevicePropertyDeviceIsRunning = %d", isrunning);

  287.             }

  288.             break;

  289.         }

  290. 

  291.         case kAudioDeviceProcessorOverload: {

  292.             jack_error("JackCoreAudioDriver::DeviceNotificationCallback kAudioDeviceProcessorOverload");

  293.             jack_time_t cur_time = GetMicroSeconds();

  294.             driver->NotifyXRun(cur_time, float(cur_time - driver->fBeginDateUst));   // Better this value than nothing...

  295.             break;

  296.         }

  297. 

  298.         case kAudioDevicePropertyStreamConfiguration: {

  299.             jack_error("Cannot handle kAudioDevicePropertyStreamConfiguration : server will quit...");

  300.             driver->NotifyFailure(JackBackendError, "Another application has changed the device configuration.");   // Message length limited to JACK_MESSAGE_SIZE

  301.             driver->CloseAUHAL();

  302.             kill(JackTools::GetPID(), SIGINT);

  303.             return kAudioHardwareUnsupportedOperationError;

  304.         }

  305. 

  306.         case kAudioDevicePropertyNominalSampleRate: {

  307.             Float64 sampleRate = 0;

  308.             UInt32 outsize = sizeof(Float64);

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

  310.             if (err != noErr)

  311.                 return kAudioHardwareUnsupportedOperationError;

  312. 

  313.             char device_name[256];

  314.             const char* digidesign_name = "Digidesign";

  315.             driver->GetDeviceNameFromID(driver->fDeviceID, device_name);

  316. 

  317.             if (sampleRate != driver->fEngineControl->fSampleRate) {

  318. 

  319.                // Digidesign hardware, so "special" code : change the SR again here

  320.                if (strncmp(device_name, digidesign_name, sizeof(digidesign_name)) == 0) {

  321. 

  322.                     jack_log("Digidesign HW = %s", device_name);

  323. 

  324.                     // Set sample rate again...

  325.                     sampleRate = driver->fEngineControl->fSampleRate;

  326.                     err = AudioDeviceSetProperty(driver->fDeviceID, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, outsize, &sampleRate);

  327.                     if (err != noErr) {

  328.                         jack_error("Cannot set sample rate = %f", sampleRate);

  329.                         printError(err);

  330.                     } else {

  331.                         jack_log("Set sample rate = %f", sampleRate);

  332.                     }

  333. 

  334.                     // Check new sample rate again...

  335.                     outsize = sizeof(Float64);

  336.                     err = AudioDeviceGetProperty(inDevice, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outsize, &sampleRate);

  337.                     if (err != noErr) {

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

  339.                         printError(err);

  340.                     } else {

  341.                         jack_log("Checked sample rate = %f", sampleRate);

  342.                     }

  343.                     return noErr;

  344. 

  345.                 } else {

  346.                     driver->NotifyFailure(JackBackendError, "Another application has changed the sample rate.");    // Message length limited to JACK_MESSAGE_SIZE

  347.                     driver->CloseAUHAL();

  348.                     kill(JackTools::GetPID(), SIGINT);

  349.                     return kAudioHardwareUnsupportedOperationError;

  350.                 }

  351.             }

  352.         }

  353. 

  354.     }

  355.     return noErr;

  356. }

  357. 

  358. OSStatus JackCoreAudioDriver::GetDeviceIDFromUID(const char* UID, AudioDeviceID* id)

  359. {

  360.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  363. 

  364.     if (inIUD == NULL) {

  365.         return kAudioHardwareUnspecifiedError;

  366.     } else {

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

  368.         CFRelease(inIUD);

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

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

  371.     }

  372. }

  373. 

  374. OSStatus JackCoreAudioDriver::GetDefaultDevice(AudioDeviceID* id)

  375. {

  376.     OSStatus res;

  377.     UInt32 theSize = sizeof(UInt32);

  378.     AudioDeviceID inDefault;

  379.     AudioDeviceID outDefault;

  380. 

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

  382.         return res;

  383. 

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

  385.         return res;

  386. 

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

  388. 

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

  390.     if (inDefault == outDefault) {

  391.         *id = inDefault;

  392.         return noErr;

  393.     } else {

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

  395.         return kAudioHardwareBadDeviceError;

  396.     }

  397. }

  398. 

  399. OSStatus JackCoreAudioDriver::GetDefaultInputDevice(AudioDeviceID* id)

  400. {

  401.     OSStatus res;

  402.     UInt32 theSize = sizeof(UInt32);

  403.     AudioDeviceID inDefault;

  404. 

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

  406.         return res;

  407. 

  408.     if (inDefault == 0) {

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

  410.         return -1;

  411.     }

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

  413.     *id = inDefault;

  414.     return noErr;

  415. }

  416. 

  417. OSStatus JackCoreAudioDriver::GetDefaultOutputDevice(AudioDeviceID* id)

  418. {

  419.     OSStatus res;

  420.     UInt32 theSize = sizeof(UInt32);

  421.     AudioDeviceID outDefault;

  422. 

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

  424.         return res;

  425. 

  426.     if (outDefault == 0) {

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

  428.         return -1;

  429.     }

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

  431.     *id = outDefault;

  432.     return noErr;

  433. }

  434. 

  435. OSStatus JackCoreAudioDriver::GetDeviceNameFromID(AudioDeviceID id, char* name)

  436. {

  437.     UInt32 size = 256;

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

  439. }

  440. 

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

  442. {

  443.     OSStatus err = noErr;

  444.     UInt32	outSize;

  445.     Boolean	outWritable;

  446. 

  447.     channelCount = 0;

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

  449.     if (err == noErr) {

  450.         AudioBufferList bufferList[outSize];

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

  452.         if (err == noErr) {

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

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

  455.         }

  456.     }

  457.     return err;

  458. }

  459. 

  460. JackCoreAudioDriver::JackCoreAudioDriver(const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table)

  461.         : JackAudioDriver(name, alias, engine, table),

  462.         fJackInputData(NULL),

  463.         fDriverOutputData(NULL),

  464.         fPluginID(0),

  465.         fState(false),

  466.         fHogged(false),

  467.         fIOUsage(1.f),

  468.         fComputationGrain(-1.f),

  469.         fClockDriftCompensate(false)

  470. {}

  471. 

  472. JackCoreAudioDriver::~JackCoreAudioDriver()

  473. {}

  474. 

  475. OSStatus JackCoreAudioDriver::DestroyAggregateDevice()

  476. {

  477.     OSStatus osErr = noErr;

  478.     AudioObjectPropertyAddress pluginAOPA;

  479.     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;

  480.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  481.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  482.     UInt32 outDataSize;

  483. 

  484.     if (fPluginID > 0)   {

  485. 

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

  487.         if (osErr != noErr) {

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

  489.             printError(osErr);

  490.             return osErr;

  491.         }

  492. 

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

  494.         if (osErr != noErr) {

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

  496.             printError(osErr);

  497.             return osErr;

  498.         }

  499. 

  500.     }

  501. 

  502.     return noErr;

  503. }

  504. 

  505. OSStatus JackCoreAudioDriver::CreateAggregateDevice(AudioDeviceID captureDeviceID, AudioDeviceID playbackDeviceID, jack_nframes_t samplerate, AudioDeviceID* outAggregateDevice)

  506. {

  507.     OSStatus err = noErr;

  508.     AudioObjectID sub_device[32];

  509.     UInt32 outSize = sizeof(sub_device);

  510. 

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

  512.     vector<AudioDeviceID> captureDeviceIDArray;

  513. 

  514.     if (err != noErr) {

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

  516.         captureDeviceIDArray.push_back(captureDeviceID);

  517.     } else {

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

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

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

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

  522.         }

  523.     }

  524. 

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

  526.     vector<AudioDeviceID> playbackDeviceIDArray;

  527. 

  528.     if (err != noErr) {

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

  530.         playbackDeviceIDArray.push_back(playbackDeviceID);

  531.     } else {

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

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

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

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

  536.         }

  537.     }

  538. 

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

  540. }

  541. 

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

  543. {

  544.     OSStatus osErr = noErr;

  545.     UInt32 outSize;

  546.     Boolean outWritable;

  547. 

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

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

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

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

  552.     UInt32 theQualifierDataSize = sizeof(AudioObjectID);

  553.     AudioClassID inClass = kAudioSubDeviceClassID;

  554.     void* theQualifierData = &inClass;

  555.     UInt32 subDevicesNum = 0;

  556. 

  557.     //---------------------------------------------------------------------------

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

  559.     //---------------------------------------------------------------------------

  560.     UInt32 keptclockdomain = 0;

  561.     UInt32 clockdomain = 0;

  562.     outSize = sizeof(UInt32);

  563.     bool need_clock_drift_compensation = false;

  564. 

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

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

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

  568.         } else  {

  569.             // Check clock domain

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

  571.             if (osErr != 0) {

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

  573.                 printError(osErr);

  574.             } else {

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

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

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

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

  579.                     need_clock_drift_compensation = true;

  580.                 }

  581.             }

  582.         }

  583.     }

  584. 

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

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

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

  588.         } else {

  589.             // Check clock domain

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

  591.             if (osErr != 0) {

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

  593.                 printError(osErr);

  594.             } else {

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

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

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

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

  599.                     need_clock_drift_compensation = true;

  600.                 }

  601.             }

  602.         }

  603.     }

  604. 

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

  606.     if (keptclockdomain == 0) {

  607.         need_clock_drift_compensation = true;

  608.     }

  609. 

  610.     //---------------------------------------------------------------------------

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

  612.     //---------------------------------------------------------------------------

  613. 

  614.     char device_name[256];

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

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

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

  618.     }

  619. 

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

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

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

  623.     }

  624. 

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

  626.     if (osErr != noErr) {

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

  628.         printError(osErr);

  629.         return osErr;

  630.     }

  631. 

  632.     AudioValueTranslation pluginAVT;

  633. 

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

  635. 

  636.     pluginAVT.mInputData = &inBundleRef;

  637.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  638.     pluginAVT.mOutputData = &fPluginID;

  639.     pluginAVT.mOutputDataSize = sizeof(fPluginID);

  640. 

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

  642.     if (osErr != noErr) {

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

  644.         printError(osErr);

  645.         return osErr;

  646.     }

  647. 

  648.     //-------------------------------------------------

  649.     // Create a CFDictionary for our aggregate device

  650.     //-------------------------------------------------

  651. 

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

  653. 

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

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

  656. 

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

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

  659. 

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

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

  662. 

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

  664.     int value = 1;

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

  666. 

  667.     SInt32 system;

  668.     Gestalt(gestaltSystemVersion, &system);

  669. 

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

  671. 

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

  673.     if (system < 0x00001054) {

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

  675.     } else {

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

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

  678.     }

  679. 

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

  681.     CFMutableArrayRef subDevicesArrayClock = NULL;

  682. 

  683.     /*

  684.     if (fClockDriftCompensate) {

  685.         if (need_clock_drift_compensation) {

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

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

  688. 

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

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

  691.                 if (UID) {

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

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

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

  695.                     //CFRelease(UID);

  696.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  697.                 }

  698.             }

  699. 

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

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

  702.                 if (UID) {

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

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

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

  706.                     //CFRelease(UID);

  707.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  708.                 }

  709.             }

  710. 

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

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

  713.         } else {

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

  715.         }

  716.     }

  717.     */

  718. 

  719.     //-------------------------------------------------

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

  721.     //-------------------------------------------------

  722. 

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

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

  725. 

  726.     vector<CFStringRef> captureDeviceUID;

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

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

  729.         if (ref == NULL)

  730.             return -1;

  731.         captureDeviceUID.push_back(ref);

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

  733.         CFArrayAppendValue(subDevicesArray, ref);

  734.    }

  735. 

  736.     vector<CFStringRef> playbackDeviceUID;

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

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

  739.         if (ref == NULL)

  740.             return -1;

  741.         playbackDeviceUID.push_back(ref);

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

  743.         CFArrayAppendValue(subDevicesArray, ref);

  744.     }

  745. 

  746.     //-----------------------------------------------------------------------

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

  748.     //-----------------------------------------------------------------------

  749. 

  750.     AudioObjectPropertyAddress pluginAOPA;

  751.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  752.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  753.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  754.     UInt32 outDataSize;

  755. 

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

  757.     if (osErr != noErr) {

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

  759.         printError(osErr);

  760.         goto error;

  761.     }

  762. 

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

  764.     if (osErr != noErr) {

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

  766.         printError(osErr);

  767.         goto error;

  768.     }

  769. 

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

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

  772.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  773. 

  774.     //-------------------------

  775.     // Set the sub-device list

  776.     //-------------------------

  777. 

  778.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  779.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  780.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  781.     outDataSize = sizeof(CFMutableArrayRef);

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

  783.     if (osErr != noErr) {

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

  785.         printError(osErr);

  786.         goto error;

  787.     }

  788. 

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

  790.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  791. 

  792.     //-----------------------

  793.     // Set the master device

  794.     //-----------------------

  795. 

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

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

  798.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  799.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  800.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  801.     outDataSize = sizeof(CFStringRef);

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

  803.     if (osErr != noErr) {

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

  805.         printError(osErr);

  806.         goto error;

  807.     }

  808. 

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

  810.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  811. 

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

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

  814. 

  815.     if (fClockDriftCompensate) {

  816.         if (need_clock_drift_compensation) {

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

  818. 

  819.             // Get the property data size

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

  821.             if (osErr != noErr) {

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

  823.                 printError(osErr);

  824.             }

  825. 

  826.             //	Calculate the number of object IDs

  827.             subDevicesNum = outSize / sizeof(AudioObjectID);

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

  829.             AudioObjectID subDevices[subDevicesNum];

  830.             outSize = sizeof(subDevices);

  831. 

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

  833.             if (osErr != noErr) {

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

  835.                 printError(osErr);

  836.             }

  837. 

  838.             // Set kAudioSubDevicePropertyDriftCompensation property...

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

  840.                 UInt32 theDriftCompensationValue = 1;

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

  842.                 if (osErr != noErr) {

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

  844.                     printError(osErr);

  845.                 }

  846.             }

  847.         } else {

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

  849.         }

  850.     }

  851. 

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

  853.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  854. 

  855.     //----------

  856.     // Clean up

  857.     //----------

  858. 

  859.     // release the private AD key

  860.     CFRelease(AggregateDeviceNumberRef);

  861. 

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

  863.     CFRelease(aggDeviceDict);

  864.     CFRelease(subDevicesArray);

  865. 

  866.     if (subDevicesArrayClock)

  867.         CFRelease(subDevicesArrayClock);

  868. 

  869.     // release the device UID

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

  871.         CFRelease(captureDeviceUID[i]);

  872.     }

  873. 

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

  875.         CFRelease(playbackDeviceUID[i]);

  876.     }

  877. 

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

  879.     return noErr;

  880. 

  881. error:

  882.     DestroyAggregateDevice();

  883.     return -1;

  884. }

  885. 

  886. int JackCoreAudioDriver::SetupDevices(const char* capture_driver_uid,

  887.                                       const char* playback_driver_uid,

  888.                                       char* capture_driver_name,

  889.                                       char* playback_driver_name,

  890.                                       jack_nframes_t samplerate)

  891. {

  892.     capture_driver_name[0] = 0;

  893.     playback_driver_name[0] = 0;

  894. 

  895.     // Duplex

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

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

  898. 

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

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

  901. 

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

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

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

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

  906.                     return -1;

  907.                 }

  908.             }

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

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

  911.                 return -1;

  912.             }

  913. 

  914.         } else {

  915. 

  916.             // Creates aggregate device

  917.             AudioDeviceID captureID, playbackID;

  918. 

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

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

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

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

  923.                     return -1;

  924.                 }

  925.             }

  926. 

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

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

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

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

  931.                     return -1;

  932.                 }

  933.             }

  934. 

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

  936.                 return -1;

  937.         }

  938. 

  939.     // Capture only

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

  941.         jack_log("JackCoreAudioDriver::Open capture only");

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

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

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

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

  946.                 return -1;

  947.             }

  948.         }

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

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

  951.             return -1;

  952.         }

  953. 

  954.     // Playback only

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

  956.         jack_log("JackCoreAudioDriver::Open playback only");

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

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

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

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

  961.                 return -1;

  962.             }

  963.         }

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

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

  966.             return -1;

  967.         }

  968. 

  969.     // Use default driver in duplex mode

  970.     } else {

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

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

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

  974. 

  975.             // Creates aggregate device

  976.             AudioDeviceID captureID, playbackID;

  977. 

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

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

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

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

  982.                     return -1;

  983.                 }

  984.             }

  985. 

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

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

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

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

  990.                     return -1;

  991.                 }

  992.             }

  993. 

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

  995.                 return -1;

  996.         }

  997.     }

  998. 

  999.     if (fHogged) {

  1000.         if (TakeHog()) {

  1001.             jack_info("Device = %ld has been hogged", fDeviceID);

  1002.         }

  1003.     }

  1004. 

  1005.     return 0;

  1006. }

  1007. 

  1008. /*

  1009. Return the max possible input channels in in_nChannels and output channels in out_nChannels.

  1010. */

  1011. int JackCoreAudioDriver::SetupChannels(bool capturing, bool playing, int& inchannels, int& outchannels, int& in_nChannels, int& out_nChannels, bool strict)

  1012. {

  1013.     OSStatus err = noErr;

  1014. 

  1015.     if (capturing) {

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

  1017.         if (err != noErr) {

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

  1019.             printError(err);

  1020.             return -1;

  1021.         } else {

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

  1023.         }

  1024.     }

  1025. 

  1026.     if (playing) {

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

  1028.         if (err != noErr) {

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

  1030.             printError(err);

  1031.             return -1;

  1032.         } else {

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

  1034.         }

  1035.     }

  1036. 

  1037.     if (inchannels > in_nChannels) {

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

  1039.         if (strict)

  1040.             return -1;

  1041.     }

  1042. 

  1043.     if (outchannels > out_nChannels) {

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

  1045.         if (strict)

  1046.             return -1;

  1047.     }

  1048. 

  1049.     if (inchannels == -1) {

  1050.         jack_log("Setup max in channels = %d", in_nChannels);

  1051.         inchannels = in_nChannels;

  1052.     }

  1053. 

  1054.     if (outchannels == -1) {

  1055.         jack_log("Setup max out channels = %d", out_nChannels);

  1056.         outchannels = out_nChannels;

  1057.     }

  1058. 

  1059.     return 0;

  1060. }

  1061. 

  1062. int JackCoreAudioDriver::SetupBufferSize(jack_nframes_t buffer_size)

  1063. {

  1064.     // Setting buffer size

  1065.     UInt32 outSize = sizeof(UInt32);

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

  1067.     if (err != noErr) {

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

  1069.         printError(err);

  1070.         return -1;

  1071.     }

  1072. 

  1073.     return 0;

  1074. }

  1075. 

  1076. int JackCoreAudioDriver::SetupSampleRate(jack_nframes_t samplerate)

  1077. {

  1078.     return SetupSampleRateAux(fDeviceID, samplerate);

  1079. }

  1080. 

  1081. int JackCoreAudioDriver::SetupSampleRateAux(AudioDeviceID inDevice, jack_nframes_t samplerate)

  1082. {

  1083.     OSStatus err = noErr;

  1084.     UInt32 outSize;

  1085.     Float64 sampleRate;

  1086. 

  1087.     // Get sample rate

  1088.     outSize =  sizeof(Float64);

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

  1090.     if (err != noErr) {

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

  1092.         printError(err);

  1093.         return -1;

  1094.     } else {

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

  1096.     }

  1097. 

  1098.     // If needed, set new sample rate

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

  1100.         sampleRate = (Float64)samplerate;

  1101. 

  1102.         // To get SR change notification

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

  1104.         if (err != noErr) {

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

  1106.             printError(err);

  1107.             return -1;

  1108.         }

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

  1110.         if (err != noErr) {

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

  1112.             printError(err);

  1113.             return -1;

  1114.         }

  1115. 

  1116.         // Waiting for SR change notification

  1117.         int count = 0;

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

  1119.             usleep(100000);

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

  1121.         }

  1122. 

  1123.         // Check new sample rate

  1124.         outSize =  sizeof(Float64);

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

  1126.         if (err != noErr) {

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

  1128.             printError(err);

  1129.         } else {

  1130.             jack_log("Checked sample rate = %f", sampleRate);

  1131.         }

  1132. 

  1133.         // Remove SR change notification

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

  1135.     }

  1136. 

  1137.     return 0;

  1138. }

  1139. 

  1140. int JackCoreAudioDriver::OpenAUHAL(bool capturing,

  1141.                                    bool playing,

  1142.                                    int inchannels,

  1143.                                    int outchannels,

  1144.                                    int in_nChannels,

  1145.                                    int out_nChannels,

  1146.                                    jack_nframes_t buffer_size,

  1147.                                    jack_nframes_t samplerate)

  1148. {

  1149.     ComponentResult err1;

  1150.     UInt32 enableIO;

  1151.     AudioStreamBasicDescription srcFormat, dstFormat;

  1152.     AudioDeviceID currAudioDeviceID;

  1153.     UInt32 size;

  1154. 

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

  1156. 

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

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

  1159.         return -1;

  1160.     }

  1161. 

  1162.     // AUHAL

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

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

  1165. 

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

  1167.     if (err1 != noErr) {

  1168.         jack_error("Error calling OpenAComponent");

  1169.         printError(err1);

  1170.         goto error;

  1171.     }

  1172. 

  1173.     err1 = AudioUnitInitialize(fAUHAL);

  1174.     if (err1 != noErr) {

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

  1176.         printError(err1);

  1177.         goto error;

  1178.     }

  1179. 

  1180.     // Start I/O

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

  1182.         enableIO = 1;

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

  1184.     } else {

  1185.         enableIO = 0;

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

  1187.     }

  1188. 

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

  1190.     if (err1 != noErr) {

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

  1192.         printError(err1);

  1193.         goto error;

  1194.     }

  1195. 

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

  1197.         enableIO = 1;

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

  1199.     } else {

  1200.         enableIO = 0;

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

  1202.     }

  1203. 

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

  1205.     if (err1 != noErr) {

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

  1207.         printError(err1);

  1208.         goto error;

  1209.     }

  1210. 

  1211.     size = sizeof(AudioDeviceID);

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

  1213.     if (err1 != noErr) {

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

  1215.         printError(err1);

  1216.         goto error;

  1217.     } else {

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

  1219.     }

  1220. 

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

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

  1223.     if (err1 != noErr) {

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

  1225.         printError(err1);

  1226.         goto error;

  1227.     }

  1228. 

  1229.     // Set buffer size

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

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

  1232.         if (err1 != noErr) {

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

  1234.             printError(err1);

  1235.             goto error;

  1236.         }

  1237.     }

  1238. 

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

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

  1241.         if (err1 != noErr) {

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

  1243.             printError(err1);

  1244.             goto error;

  1245.         }

  1246.     }

  1247. 

  1248.     // Setup channel map

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

  1250.         SInt32 chanArr[in_nChannels];

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

  1252.             chanArr[i] = -1;

  1253.         }

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

  1255.             chanArr[i] = i;

  1256.         }

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

  1258.         if (err1 != noErr) {

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

  1260.             printError(err1);

  1261.             goto error;

  1262.         }

  1263.     }

  1264. 

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

  1266.         SInt32 chanArr[out_nChannels];

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

  1268.             chanArr[i] = -1;

  1269.         }

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

  1271.             chanArr[i] = i;

  1272.         }

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

  1274.         if (err1 != noErr) {

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

  1276.             printError(err1);

  1277.             goto error;

  1278.         }

  1279.     }

  1280. 

  1281.     // Setup stream converters

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

  1283. 

  1284.         size = sizeof(AudioStreamBasicDescription);

  1285.         err1 = AudioUnitGetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &srcFormat, &size);

  1286.         if (err1 != noErr) {

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

  1288.             printError(err1);

  1289.             goto error;

  1290.         }

  1291.         PrintStreamDesc(&srcFormat);

  1292. 

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

  1294.         srcFormat.mSampleRate = samplerate;

  1295.         srcFormat.mFormatID = kAudioFormatLinearPCM;

  1296.         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1297.         srcFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1298.         srcFormat.mFramesPerPacket = 1;

  1299.         srcFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1300.         srcFormat.mChannelsPerFrame = inchannels;

  1301.         srcFormat.mBitsPerChannel = 32;

  1302.         PrintStreamDesc(&srcFormat);

  1303. 

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

  1305.         if (err1 != noErr) {

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

  1307.             printError(err1);

  1308.             goto error;

  1309.         }

  1310.     }

  1311. 

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

  1313. 

  1314.         size = sizeof(AudioStreamBasicDescription);

  1315.         err1 = AudioUnitGetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &dstFormat, &size);

  1316.         if (err1 != noErr) {

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

  1318.             printError(err1);

  1319.             goto error;

  1320.         }

  1321.         PrintStreamDesc(&dstFormat);

  1322. 

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

  1324.         dstFormat.mSampleRate = samplerate;

  1325.         dstFormat.mFormatID = kAudioFormatLinearPCM;

  1326.         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1327.         dstFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1328.         dstFormat.mFramesPerPacket = 1;

  1329.         dstFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1330.         dstFormat.mChannelsPerFrame = outchannels;

  1331.         dstFormat.mBitsPerChannel = 32;

  1332.         PrintStreamDesc(&dstFormat);

  1333. 

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

  1335.         if (err1 != noErr) {

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

  1337.             printError(err1);

  1338.             goto error;

  1339.         }

  1340.     }

  1341. 

  1342.     // Setup callbacks

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

  1344.         AURenderCallbackStruct output;

  1345.         output.inputProc = Render;

  1346.         output.inputProcRefCon = this;

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

  1348.         if (err1 != noErr) {

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

  1350.             printError(err1);

  1351.             goto error;

  1352.         }

  1353.     } else {

  1354.         AURenderCallbackStruct output;

  1355.         output.inputProc = Render;

  1356.         output.inputProcRefCon = this;

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

  1358.         if (err1 != noErr) {

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

  1360.             printError(err1);

  1361.             goto error;

  1362.         }

  1363.     }

  1364. 

  1365.     return 0;

  1366. 

  1367. error:

  1368.     CloseAUHAL();

  1369.     return -1;

  1370. }

  1371. 

  1372. int JackCoreAudioDriver::SetupBuffers(int inchannels)

  1373. {

  1374.     // Prepare buffers

  1375.     fJackInputData = (AudioBufferList*)malloc(sizeof(UInt32) + inchannels * sizeof(AudioBuffer));

  1376.     fJackInputData->mNumberBuffers = inchannels;

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

  1378.         fJackInputData->mBuffers[i].mNumberChannels = 1;

  1379.         fJackInputData->mBuffers[i].mDataByteSize = fEngineControl->fBufferSize * sizeof(jack_default_audio_sample_t);

  1380.     }

  1381.     return 0;

  1382. }

  1383. 

  1384. void JackCoreAudioDriver::DisposeBuffers()

  1385. {

  1386.     if (fJackInputData) {

  1387.         free(fJackInputData);

  1388.         fJackInputData = 0;

  1389.     }

  1390. }

  1391. 

  1392. void JackCoreAudioDriver::CloseAUHAL()

  1393. {

  1394.     AudioUnitUninitialize(fAUHAL);

  1395.     CloseComponent(fAUHAL);

  1396. }

  1397. 

  1398. int JackCoreAudioDriver::AddListeners()

  1399. {

  1400.     OSStatus err = noErr;

  1401. 

  1402.     // Add listeners

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

  1404.     if (err != noErr) {

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

  1406.         printError(err);

  1407.         return -1;

  1408.     }

  1409. 

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

  1411.     if (err != noErr) {

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

  1413.         printError(err);

  1414.         return -1;

  1415.     }

  1416. 

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

  1418.     if (err != noErr) {

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

  1420.         printError(err);

  1421.         return -1;

  1422.     }

  1423. 

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

  1425.     if (err != noErr) {

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

  1427.         printError(err);

  1428.         return -1;

  1429.     }

  1430. 

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

  1432.     if (err != noErr) {

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

  1434.         printError(err);

  1435.         return -1;

  1436.     }

  1437. 

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

  1439.     if (err != noErr) {

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

  1441.         printError(err);

  1442.         return -1;

  1443.     }

  1444. 

  1445.     if (!fEngineControl->fSyncMode && fIOUsage != 1.f) {

  1446.         UInt32 outSize = sizeof(float);

  1447.         err = AudioDeviceSetProperty(fDeviceID, NULL, 0, false, kAudioDevicePropertyIOCycleUsage, outSize, &fIOUsage);

  1448.         if (err != noErr) {

  1449.             jack_error("Error calling AudioDeviceSetProperty kAudioDevicePropertyIOCycleUsage");

  1450.             printError(err);

  1451.         }

  1452.     }

  1453. 

  1454.     return 0;

  1455. }

  1456. 

  1457. void JackCoreAudioDriver::RemoveListeners()

  1458. {

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

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

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

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

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

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

  1465. }

  1466. 

  1467. int JackCoreAudioDriver::Open(jack_nframes_t buffer_size,

  1468.                               jack_nframes_t samplerate,

  1469.                               bool capturing,

  1470.                               bool playing,

  1471.                               int inchannels,

  1472.                               int outchannels,

  1473.                               bool monitor,

  1474.                               const char* capture_driver_uid,

  1475.                               const char* playback_driver_uid,

  1476.                               jack_nframes_t capture_latency,

  1477.                               jack_nframes_t playback_latency,

  1478.                               int async_output_latency,

  1479.                               int computation_grain,

  1480.                               bool hogged,

  1481.                               bool clock_drift)

  1482. {

  1483.     int in_nChannels = 0;

  1484.     int out_nChannels = 0;

  1485.     char capture_driver_name[256];

  1486.     char playback_driver_name[256];

  1487. 

  1488.     // Keep initial state

  1489.     strcpy(fCaptureUID, capture_driver_uid);

  1490.     strcpy(fPlaybackUID, playback_driver_uid);

  1491.     fCaptureLatency = capture_latency;

  1492.     fPlaybackLatency = playback_latency;

  1493.     fIOUsage = float(async_output_latency) / 100.f;

  1494.     fComputationGrain = float(computation_grain) / 100.f;

  1495.     fHogged = hogged;

  1496.     fClockDriftCompensate = clock_drift;

  1497. 

  1498.     SInt32 major;

  1499.     SInt32 minor;

  1500.     Gestalt(gestaltSystemVersionMajor, &major);

  1501.     Gestalt(gestaltSystemVersionMinor, &minor);

  1502. 

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

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

  1505.         CFRunLoopRef theRunLoop = NULL;

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

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

  1508.         if (osErr != noErr) {

  1509.             jack_error("JackCoreAudioDriver::Open kAudioHardwarePropertyRunLoop error");

  1510.             printError(osErr);

  1511.         }

  1512.     }

  1513. 

  1514.     if (SetupDevices(capture_driver_uid, playback_driver_uid, capture_driver_name, playback_driver_name, samplerate) < 0)

  1515.         goto error;

  1516. 

  1517.     // Generic JackAudioDriver Open

  1518.     if (JackAudioDriver::Open(buffer_size, samplerate, capturing, playing, inchannels, outchannels, monitor, capture_driver_name, playback_driver_name, capture_latency, playback_latency) != 0)

  1519.         goto error;

  1520. 

  1521.     if (SetupChannels(capturing, playing, inchannels, outchannels, in_nChannels, out_nChannels, true) < 0)

  1522.         goto error;

  1523. 

  1524.     if (SetupBufferSize(buffer_size) < 0)

  1525.         goto error;

  1526. 

  1527.     if (SetupSampleRate(samplerate) < 0)

  1528.         goto error;

  1529. 

  1530.     if (OpenAUHAL(capturing, playing, inchannels, outchannels, in_nChannels, out_nChannels, buffer_size, samplerate) < 0)

  1531.         goto error;

  1532. 

  1533.     if (capturing && inchannels > 0)

  1534.         if (SetupBuffers(inchannels) < 0)

  1535.             goto error;

  1536. 

  1537.     if (AddListeners() < 0)

  1538.         goto error;

  1539. 

  1540.     // Core driver may have changed the in/out values

  1541.     fCaptureChannels = inchannels;

  1542.     fPlaybackChannels = outchannels;

  1543.     return noErr;

  1544. 

  1545. error:

  1546.     Close();

  1547.     return -1;

  1548. }

  1549. 

  1550. int JackCoreAudioDriver::Close()

  1551. {

  1552.     jack_log("JackCoreAudioDriver::Close");

  1553.     Stop();

  1554. 

  1555.     // Generic audio driver close

  1556.     int res = JackAudioDriver::Close();

  1557. 

  1558.     RemoveListeners();

  1559.     DisposeBuffers();

  1560.     CloseAUHAL();

  1561.     DestroyAggregateDevice();

  1562.     return res;

  1563. }

  1564. 

  1565. int JackCoreAudioDriver::Attach()

  1566. {

  1567.     OSStatus err;

  1568.     JackPort* port;

  1569.     jack_port_id_t port_index;

  1570.     UInt32 size;

  1571.     Boolean isWritable;

  1572.     char channel_name[64];

  1573.     char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  1574.     char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  1575.     jack_latency_range_t range;

  1576. 

  1577.     jack_log("JackCoreAudioDriver::Attach fBufferSize %ld fSampleRate %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate);

  1578. 

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

  1580. 

  1581.         err = AudioDeviceGetPropertyInfo(fDeviceID, i + 1, true, kAudioDevicePropertyChannelName, &size, &isWritable);

  1582.         if (err != noErr)

  1583.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

  1584.         if (err == noErr && size > 0) {

  1585.             err = AudioDeviceGetProperty(fDeviceID, i + 1, true, kAudioDevicePropertyChannelName, &size, channel_name);

  1586.             if (err != noErr)

  1587.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

  1588.             snprintf(alias, sizeof(alias) - 1, "%s:%s:out_%s%u", fAliasName, fCaptureDriverName, channel_name, i + 1);

  1589.         } else {

  1590.             snprintf(alias, sizeof(alias) - 1, "%s:%s:out%u", fAliasName, fCaptureDriverName, i + 1);

  1591.         }

  1592. 

  1593.         snprintf(name, sizeof(name) - 1, "%s:capture_%d", fClientControl.fName, i + 1);

  1594. 

  1595.         if ((port_index = fGraphManager->AllocatePort(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, CaptureDriverFlags, fEngineControl->fBufferSize)) == NO_PORT) {

  1596.             jack_error("Cannot register port for %s", name);

  1597.             return -1;

  1598.         }

  1599. 

  1600.         size = sizeof(UInt32);

  1601.         UInt32 value1 = 0;

  1602.         UInt32 value2 = 0;

  1603.         err = AudioDeviceGetProperty(fDeviceID, 0, true, kAudioDevicePropertyLatency, &size, &value1);

  1604.         if (err != noErr)

  1605.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

  1606.         err = AudioDeviceGetProperty(fDeviceID, 0, true, kAudioDevicePropertySafetyOffset, &size, &value2);

  1607.         if (err != noErr)

  1608.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  1609. 

  1610.         port = fGraphManager->GetPort(port_index);

  1611.         port->SetAlias(alias);

  1612.         range.min = range.max = fEngineControl->fBufferSize + value1 + value2 + fCaptureLatency;

  1613.         port->SetLatencyRange(JackCaptureLatency, &range);

  1614.         fCapturePortList[i] = port_index;

  1615.     }

  1616. 

  1617.     for (int i = 0; i < fPlaybackChannels; i++) {

  1618. 

  1619.         err = AudioDeviceGetPropertyInfo(fDeviceID, i + 1, false, kAudioDevicePropertyChannelName, &size, &isWritable);

  1620.         if (err != noErr)

  1621.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

  1622.         if (err == noErr && size > 0) {

  1623.             err = AudioDeviceGetProperty(fDeviceID, i + 1, false, kAudioDevicePropertyChannelName, &size, channel_name);

  1624.             if (err != noErr)

  1625.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

  1626.             snprintf(alias, sizeof(alias) - 1, "%s:%s:in_%s%u", fAliasName, fPlaybackDriverName, channel_name, i + 1);

  1627.         } else {

  1628.             snprintf(alias, sizeof(alias) - 1, "%s:%s:in%u", fAliasName, fPlaybackDriverName, i + 1);

  1629.         }

  1630. 

  1631.         snprintf(name, sizeof(name) - 1, "%s:playback_%d", fClientControl.fName, i + 1);

  1632. 

  1633.         if ((port_index = fGraphManager->AllocatePort(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, PlaybackDriverFlags, fEngineControl->fBufferSize)) == NO_PORT) {

  1634.             jack_error("Cannot register port for %s", name);

  1635.             return -1;

  1636.         }

  1637. 

  1638.         size = sizeof(UInt32);

  1639.         UInt32 value1 = 0;

  1640.         UInt32 value2 = 0;

  1641.         err = AudioDeviceGetProperty(fDeviceID, 0, false, kAudioDevicePropertyLatency, &size, &value1);

  1642.         if (err != noErr)

  1643.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

  1644.         err = AudioDeviceGetProperty(fDeviceID, 0, false, kAudioDevicePropertySafetyOffset, &size, &value2);

  1645.         if (err != noErr)

  1646.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  1647. 

  1648.         port = fGraphManager->GetPort(port_index);

  1649.         port->SetAlias(alias);

  1650.         // Add more latency if "async" mode is used...

  1651.         range.min = range.max = fEngineControl->fBufferSize + ((fEngineControl->fSyncMode) ? 0 : fEngineControl->fBufferSize * fIOUsage) + value1 + value2 + fPlaybackLatency;

  1652.         port->SetLatencyRange(JackPlaybackLatency, &range);

  1653.         fPlaybackPortList[i] = port_index;

  1654. 

  1655.         // Monitor ports

  1656.         if (fWithMonitorPorts) {

  1657.             jack_log("Create monitor port ");

  1658.             snprintf(name, sizeof(name) - 1, "%s:monitor_%u", fClientControl.fName, i + 1);

  1659.             if ((port_index = fGraphManager->AllocatePort(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, MonitorDriverFlags, fEngineControl->fBufferSize)) == NO_PORT) {

  1660.                 jack_error("Cannot register monitor port for %s", name);

  1661.                 return -1;

  1662.             } else {

  1663.                 port = fGraphManager->GetPort(port_index);

  1664.                 port->SetAlias(alias);

  1665.                 range.min = range.max = fEngineControl->fBufferSize;

  1666.                 port->SetLatencyRange(JackCaptureLatency, &range);

  1667.                 fMonitorPortList[i] = port_index;

  1668.             }

  1669.         }

  1670.     }

  1671. 

  1672.     // Input buffers do no change : prepare them only once

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

  1674.         fJackInputData->mBuffers[i].mData = GetInputBuffer(i);

  1675.     }

  1676. 

  1677.     return 0;

  1678. }

  1679. 

  1680. int JackCoreAudioDriver::Start()

  1681. {

  1682.     jack_log("JackCoreAudioDriver::Start");

  1683.     JackAudioDriver::Start();

  1684. 

  1685.     OSStatus err = AudioOutputUnitStart(fAUHAL);

  1686.     if (err != noErr)

  1687.         return -1;

  1688. 

  1689.     // Waiting for Measure callback to be called (= driver has started)

  1690.     fState = false;

  1691.     int count = 0;

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

  1693.         usleep(100000);

  1694.         jack_log("JackCoreAudioDriver::Start wait count = %d", count);

  1695.     }

  1696. 

  1697.     if (count < WAIT_COUNTER) {

  1698.         jack_info("CoreAudio driver is running...");

  1699.         return 0;

  1700.     } else {

  1701.         jack_error("CoreAudio driver cannot start...");

  1702.         return -1;

  1703.     }

  1704. }

  1705. 

  1706. int JackCoreAudioDriver::Stop()

  1707. {

  1708.     jack_log("JackCoreAudioDriver::Stop");

  1709.     return (AudioOutputUnitStop(fAUHAL) == noErr) ? 0 : -1;

  1710. }

  1711. 

  1712. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  1713. {

  1714.     OSStatus err;

  1715.     UInt32 outSize = sizeof(UInt32);

  1716. 

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

  1718.     if (err != noErr) {

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

  1720.         printError(err);

  1721.         return -1;

  1722.     }

  1723. 

  1724.     JackAudioDriver::SetBufferSize(buffer_size); // never fails

  1725. 

  1726.     // Input buffers do no change : prepare them only once

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

  1728.         fJackInputData->mBuffers[i].mNumberChannels = 1;

  1729.         fJackInputData->mBuffers[i].mDataByteSize = fEngineControl->fBufferSize * sizeof(jack_default_audio_sample_t);

  1730.         fJackInputData->mBuffers[i].mData = GetInputBuffer(i);

  1731.     }

  1732. 

  1733.     return 0;

  1734. }

  1735. 

  1736. bool JackCoreAudioDriver::TakeHogAux(AudioDeviceID deviceID, bool isInput)

  1737. {

  1738.     pid_t hog_pid;

  1739.     OSStatus err;

  1740. 

  1741.     UInt32 propSize = sizeof(hog_pid);

  1742.     err = AudioDeviceGetProperty(deviceID, 0, isInput, kAudioDevicePropertyHogMode, &propSize, &hog_pid);

  1743.     if (err) {

  1744.         jack_error("Cannot read hog state...");

  1745.         printError(err);

  1746.     }

  1747. 

  1748.     if (hog_pid != getpid()) {

  1749.         hog_pid = getpid();

  1750.         err = AudioDeviceSetProperty(deviceID, 0, 0, isInput, kAudioDevicePropertyHogMode, propSize, &hog_pid);

  1751.         if (err != noErr) {

  1752.             jack_error("Can't hog device = %d because it's being hogged by another program or cannot be hogged", deviceID);

  1753.             return false;

  1754.         }

  1755.     }

  1756. 

  1757.     return true;

  1758. }

  1759. 

  1760. bool JackCoreAudioDriver::TakeHog()

  1761. {

  1762.     OSStatus err = noErr;

  1763.     AudioObjectID sub_device[32];

  1764.     UInt32 outSize = sizeof(sub_device);

  1765.     err = AudioDeviceGetProperty(fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioAggregateDevicePropertyActiveSubDeviceList, &outSize, sub_device);

  1766. 

  1767.     if (err != noErr) {

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

  1769.         return TakeHogAux(fDeviceID, true);

  1770.     } else {

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

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

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

  1774.             if (!TakeHogAux(sub_device[i], true)) {

  1775.                 return false;

  1776.             }

  1777.         }

  1778.         return true;

  1779.     }

  1780. }

  1781. 

  1782. bool JackCoreAudioDriver::IsAggregateDevice(AudioDeviceID device)

  1783. {

  1784.     UInt32 deviceType, outSize = sizeof(UInt32);

  1785.     OSStatus err = AudioDeviceGetProperty(device, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyTransportType, &outSize, &deviceType);

  1786. 

  1787.     if (err != noErr) {

  1788.         jack_log("JackCoreAudioDriver::IsAggregateDevice kAudioDevicePropertyTransportType error");

  1789.         return false;

  1790.     } else {

  1791.         return (deviceType == kAudioDeviceTransportTypeAggregate);

  1792.     }

  1793. }

  1794. 

  1795. 

  1796. } // end of namespace

  1797. 

  1798. 

  1799. #ifdef __cplusplus

  1800. extern "C"

  1801. {

  1802. #endif

  1803. 

  1804.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor()

  1805.     {

  1806.         jack_driver_desc_t *desc;

  1807.         unsigned int i;

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

  1809. 

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

  1811.         strcpy(desc->desc, "Apple CoreAudio API based audio backend");      // size MUST be less then JACK_DRIVER_PARAM_DESC + 1

  1812. 

  1813.         desc->nparams = 17;

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

  1815. 

  1816.         i = 0;

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

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

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

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

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

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

  1823. 

  1824.         i++;

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

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

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

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

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

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

  1831. 

  1832.         i++;

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

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

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

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

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

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

  1839. 

  1840.         i++;

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

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

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

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

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

  1846. 

  1847.         i++;

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

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

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

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

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

  1853. 

  1854.         i++;

  1855.         strcpy (desc->params[i].name, "monitor");

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

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

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

  1859.         strcpy(desc->params[i].short_desc, "Provide monitor ports for the output");

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

  1861. 

  1862.         i++;

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

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

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

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

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

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

  1869. 

  1870.         i++;

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

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

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

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

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

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

  1877. 

  1878.         i++;

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

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

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

  1882.         desc->params[i].value.ui = 128U;

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

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

  1885. 

  1886.         i++;

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

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

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

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

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

  1892. 

  1893.         i++;

  1894.         strcpy(desc->params[i].name, "input-latency");

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

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

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

  1898.         strcpy(desc->params[i].short_desc, "Extra input latency (frames)");

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

  1900. 

  1901.         i++;

  1902.         strcpy(desc->params[i].name, "output-latency");

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

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

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

  1906.         strcpy(desc->params[i].short_desc, "Extra output latency (frames)");

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

  1908. 

  1909.         i++;

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

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

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

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

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

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

  1916. 

  1917.         i++;

  1918.         strcpy(desc->params[i].name, "hog");

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

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

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

  1922.         strcpy(desc->params[i].short_desc, "Take exclusive access of the audio device");

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

  1924. 

  1925.         i++;

  1926.         strcpy(desc->params[i].name, "async-latency");

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

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

  1929.         desc->params[i].value.i = 100;

  1930.         strcpy(desc->params[i].short_desc, "Extra output latency in asynchronous mode (percent)");

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

  1932. 

  1933.         i++;

  1934.         strcpy(desc->params[i].name, "grain");

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

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

  1937.         desc->params[i].value.i = 100;

  1938.         strcpy(desc->params[i].short_desc, "Computation grain in RT thread (percent)");

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

  1940. 

  1941.         i++;

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

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

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

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

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

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

  1948. 

  1949.         return desc;

  1950.     }

  1951. 

  1952.     SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize(Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params)

  1953.     {

  1954.         jack_nframes_t srate = 44100;

  1955.         jack_nframes_t frames_per_interrupt = 128;

  1956.         bool capture = false;

  1957.         bool playback = false;

  1958.         int chan_in = -1;   // Default: if not explicitely set, then max possible will be used...

  1959.         int chan_out = -1;  // Default: if not explicitely set, then max possible will be used...

  1960.         bool monitor = false;

  1961.         const char* capture_driver_uid = "";

  1962.         const char* playback_driver_uid = "";

  1963.         const JSList *node;

  1964.         const jack_driver_param_t *param;

  1965.         jack_nframes_t systemic_input_latency = 0;

  1966.         jack_nframes_t systemic_output_latency = 0;

  1967.         int async_output_latency = 100;

  1968.         int computation_grain = -1;

  1969.         bool hogged = false;

  1970.         bool clock_drift = false;

  1971. 

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

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

  1974. 

  1975.             switch (param->character) {

  1976. 

  1977.                 case 'd':

  1978.                     capture_driver_uid = param->value.str;

  1979.                     playback_driver_uid = param->value.str;

  1980.                     break;

  1981. 

  1982.                 case 'D':

  1983.                     capture = true;

  1984.                     playback = true;

  1985.                     break;

  1986. 

  1987.                 case 'c':

  1988.                     chan_in = chan_out = (int)param->value.ui;

  1989.                     break;

  1990. 

  1991.                 case 'i':

  1992.                     chan_in = (int)param->value.ui;

  1993.                     break;

  1994. 

  1995.                 case 'o':

  1996.                     chan_out = (int)param->value.ui;

  1997.                     break;

  1998. 

  1999.                 case 'C':

  2000.                     capture = true;

  2001.                     if (strcmp(param->value.str, "none") != 0) {

  2002.                         capture_driver_uid = param->value.str;

  2003.                     }

  2004.                     break;

  2005. 

  2006.                 case 'P':

  2007.                     playback = true;

  2008.                     if (strcmp(param->value.str, "none") != 0) {

  2009.                         playback_driver_uid = param->value.str;

  2010.                     }

  2011.                     break;

  2012. 

  2013.                 case 'm':

  2014.                     monitor = param->value.i;

  2015.                     break;

  2016. 

  2017.                 case 'r':

  2018.                     srate = param->value.ui;

  2019.                     break;

  2020. 

  2021.                 case 'p':

  2022.                     frames_per_interrupt = (unsigned int)param->value.ui;

  2023.                     break;

  2024. 

  2025.                 case 'I':

  2026.                     systemic_input_latency = param->value.ui;

  2027.                     break;

  2028. 

  2029.                 case 'O':

  2030.                     systemic_output_latency = param->value.ui;

  2031.                     break;

  2032. 

  2033.                 case 'l':

  2034.                     Jack::DisplayDeviceNames();

  2035.                     break;

  2036. 

  2037.                 case 'H':

  2038.                     hogged = true;

  2039.                     break;

  2040. 

  2041.                 case 'L':

  2042.                     async_output_latency = param->value.ui;

  2043.                     break;

  2044. 

  2045.                 case 'G':

  2046.                     computation_grain = param->value.ui;

  2047.                     break;

  2048. 

  2049.                 case 's':

  2050.                     clock_drift = true;

  2051.                     break;

  2052.             }

  2053.         }

  2054. 

  2055.         /* duplex is the default */

  2056.         if (!capture && !playback) {

  2057.             capture = true;

  2058.             playback = true;

  2059.         }

  2060. 

  2061.         Jack::JackCoreAudioDriver* driver = new Jack::JackCoreAudioDriver("system", "coreaudio", engine, table);

  2062.         if (driver->Open(frames_per_interrupt, srate, capture, playback, chan_in, chan_out, monitor, capture_driver_uid,

  2063.             playback_driver_uid, systemic_input_latency, systemic_output_latency, async_output_latency, computation_grain, hogged, clock_drift) == 0) {

  2064.             return driver;

  2065.         } else {

  2066.             delete driver;

  2067.             return NULL;

  2068.         }

  2069.     }

  2070. 

  2071. #ifdef __cplusplus

  2072. }

  2073. #endif

  2074.