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

2022 lines
78KB
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.     driver->CycleTakeBeginTime();

  198.     return driver->Process();

  199. }

  200. 

  201. int JackCoreAudioDriver::Read()

  202. {

  203.     AudioUnitRender(fAUHAL, fActionFags, fCurrentTime, 1, fEngineControl->fBufferSize, fJackInputData);

  204.     return 0;

  205. }

  206. 

  207. int JackCoreAudioDriver::Write()

  208. {

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

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

  211.             float* buffer = GetOutputBuffer(i);

  212.             int size = sizeof(float) * fEngineControl->fBufferSize;

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

  214.             // Monitor ports

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

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

  217.         } else {

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

  219.         }

  220.     }

  221.     return 0;

  222. }

  223. 

  224. // Will run only once

  225. OSStatus JackCoreAudioDriver::MeasureCallback(AudioDeviceID inDevice,

  226.         const AudioTimeStamp* inNow,

  227.         const AudioBufferList* inInputData,

  228.         const AudioTimeStamp* inInputTime,

  229.         AudioBufferList* outOutputData,

  230.         const AudioTimeStamp* inOutputTime,

  231.         void* inClientData)

  232. {

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

  234.     AudioDeviceStop(driver->fDeviceID, MeasureCallback);

  235.     

  236.     jack_log("JackCoreAudioDriver::MeasureCallback called");

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

  238.     

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

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

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

  242.     }

  243.     

  244.     // Signal waiting start function...

  245.     driver->fState = true;

  246.     

  247.     // Setup threadded based log function

  248.     set_threaded_log_function();

  249.     return noErr;

  250. }

  251. 

  252. OSStatus JackCoreAudioDriver::SRNotificationCallback(AudioDeviceID inDevice,

  253.         UInt32 inChannel,

  254.         Boolean	isInput,

  255.         AudioDevicePropertyID inPropertyID,

  256.         void* inClientData)

  257. {

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

  259. 

  260.     switch (inPropertyID) {

  261. 

  262.         case kAudioDevicePropertyNominalSampleRate: {

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

  264.             driver->fState = true;

  265.             break;

  266.         }

  267.     }

  268. 

  269.     return noErr;

  270. }

  271. 

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

  273. OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,

  274.         UInt32 inChannel,

  275.         Boolean	isInput,

  276.         AudioDevicePropertyID inPropertyID,

  277.         void* inClientData)

  278. {

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

  280.          

  281.     switch (inPropertyID) {

  282.         

  283.         case kAudioDeviceProcessorOverload: {

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

  285.             jack_time_t cur_time = GetMicroSeconds();

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

  287.             break;

  288.         }

  289.         

  290.         case kAudioDevicePropertyStreamConfiguration: {

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

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

  293.             driver->CloseAUHAL();

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

  295.             return kAudioHardwareUnsupportedOperationError;

  296.         }

  297.         

  298.         case kAudioDevicePropertyNominalSampleRate: {

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

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

  301.             driver->CloseAUHAL();

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

  303.             return kAudioHardwareUnsupportedOperationError;

  304. 		}

  305.             

  306.     }

  307.     return noErr;

  308. }

  309. 

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

  311. {

  312.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  315. 

  316.     if (inIUD == NULL) {

  317.         return kAudioHardwareUnspecifiedError;

  318.     } else {

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

  320.         CFRelease(inIUD);

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

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

  323.     }

  324. }

  325. 

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

  327. {

  328.     OSStatus res;

  329.     UInt32 theSize = sizeof(UInt32);

  330.     AudioDeviceID inDefault;

  331.     AudioDeviceID outDefault;

  332. 

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

  334.         return res;

  335. 

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

  337.         return res;

  338. 

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

  340. 

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

  342.     if (inDefault == outDefault) {

  343.         *id = inDefault;

  344.         return noErr;

  345.     } else {

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

  347.         return kAudioHardwareBadDeviceError;

  348.     }

  349. }

  350. 

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

  352. {

  353.     OSStatus res;

  354.     UInt32 theSize = sizeof(UInt32);

  355.     AudioDeviceID inDefault;

  356. 

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

  358.         return res;

  359. 

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

  361.     *id = inDefault;

  362.     return noErr;

  363. }

  364. 

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

  366. {

  367.     OSStatus res;

  368.     UInt32 theSize = sizeof(UInt32);

  369.     AudioDeviceID outDefault;

  370. 

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

  372.         return res;

  373. 

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

  375.     *id = outDefault;

  376.     return noErr;

  377. }

  378. 

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

  380. {

  381.     UInt32 size = 256;

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

  383. }

  384. 

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

  386. {

  387.     OSStatus err = noErr;

  388.     UInt32	outSize;

  389.     Boolean	outWritable;

  390.  

  391.     channelCount = 0;

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

  393.     if (err == noErr) {

  394.         AudioBufferList bufferList[outSize];

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

  396.         if (err == noErr) {

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

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

  399.         }

  400.     }

  401.     return err;

  402. }

  403. 

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

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

  406.         fJackInputData(NULL), 

  407.         fDriverOutputData(NULL), 

  408.         fPluginID(0), 

  409.         fState(false), 

  410.         fHogged(false),

  411.         fIOUsage(1.f),

  412.         fComputationGrain(-1.f),

  413.         fClockDriftCompensate(false)

  414. {}

  415. 

  416. JackCoreAudioDriver::~JackCoreAudioDriver()

  417. {}

  418. 

  419. OSStatus JackCoreAudioDriver::DestroyAggregateDevice() 

  420. {

  421.     OSStatus osErr = noErr;

  422.     AudioObjectPropertyAddress pluginAOPA;

  423.     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;

  424.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  425.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  426.     UInt32 outDataSize;

  427.      

  428.     if (fPluginID > 0)   {

  429.       

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

  431.         if (osErr != noErr) {

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

  433.             printError(osErr);

  434.             return osErr;

  435.         }

  436.             

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

  438.         if (osErr != noErr) {

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

  440.             printError(osErr);

  441.             return osErr;

  442.         }

  443.         

  444.     }

  445.     

  446.     return noErr;

  447. }

  448.     

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

  450. {

  451.     OSStatus err = noErr;

  452.     AudioObjectID sub_device[32];

  453.     UInt32 outSize = sizeof(sub_device);

  454.     

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

  456.     vector<AudioDeviceID> captureDeviceIDArray;

  457.     

  458.     if (err != noErr) {

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

  460.         captureDeviceIDArray.push_back(captureDeviceID);

  461.     } else {

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

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

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

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

  466.         }

  467.     }

  468.     

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

  470.     vector<AudioDeviceID> playbackDeviceIDArray;

  471.     

  472.     if (err != noErr) {

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

  474.         playbackDeviceIDArray.push_back(playbackDeviceID);

  475.     } else {

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

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

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

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

  480.         }

  481.     }

  482.     

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

  484. }

  485. 

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

  487. {

  488.     OSStatus osErr = noErr;

  489.     UInt32 outSize;

  490.     Boolean outWritable;

  491.     

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

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

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

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

  496.     UInt32 theQualifierDataSize = sizeof(AudioObjectID);

  497.     AudioClassID inClass = kAudioSubDeviceClassID;

  498.     void* theQualifierData = &inClass;

  499.     UInt32 subDevicesNum = 0;

  500.      

  501.     //---------------------------------------------------------------------------

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

  503.     //---------------------------------------------------------------------------

  504.     UInt32 keptclockdomain = 0;

  505.     UInt32 clockdomain = 0;

  506.     outSize = sizeof(UInt32);

  507.     bool need_clock_drift_compensation = false;

  508.     

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

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

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

  512.         } else  {

  513.             // Check clock domain

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

  515.             if (osErr != 0) {

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

  517.                 printError(osErr);

  518.             } else {

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

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

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

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

  523.                     need_clock_drift_compensation = true;

  524.                 }

  525.             }

  526.         }

  527.     }

  528.     

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

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

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

  532.         } else {

  533.             // Check clock domain

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

  535.             if (osErr != 0) {

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

  537.                 printError(osErr);

  538.             } else {

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

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

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

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

  543.                     need_clock_drift_compensation = true;

  544.                 }

  545.             }

  546.         }

  547.     }

  548.     

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

  550.     if (keptclockdomain == 0) {

  551.         need_clock_drift_compensation = true;

  552.     }

  553. 

  554.     //---------------------------------------------------------------------------

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

  556.     //---------------------------------------------------------------------------

  557.     

  558.     char device_name[256];

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

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

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

  562.     }

  563.     

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

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

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

  567.     }

  568.    

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

  570.     if (osErr != noErr) {

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

  572.         printError(osErr);

  573.         return osErr;

  574.     }

  575. 

  576.     AudioValueTranslation pluginAVT;

  577. 

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

  579.    

  580.     pluginAVT.mInputData = &inBundleRef;

  581.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  582.     pluginAVT.mOutputData = &fPluginID;

  583.     pluginAVT.mOutputDataSize = sizeof(fPluginID);

  584. 

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

  586.     if (osErr != noErr) {

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

  588.         printError(osErr);

  589.         return osErr;

  590.     }

  591. 

  592.     //-------------------------------------------------

  593.     // Create a CFDictionary for our aggregate device

  594.     //-------------------------------------------------

  595. 

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

  597. 

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

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

  600.     

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

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

  603. 

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

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

  606.     

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

  608.     int value = 1;

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

  610.     

  611.     SInt32 system;

  612.     Gestalt(gestaltSystemVersion, &system);

  613.      

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

  615.     

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

  617.     if (system < 0x00001054) {

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

  619.     } else {

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

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

  622.     }

  623.     

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

  625.     CFMutableArrayRef subDevicesArrayClock = NULL;

  626.     

  627.     /*

  628.     if (fClockDriftCompensate) {

  629.         if (need_clock_drift_compensation) {

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

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

  632.             

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

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

  635.                 if (UID) {

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

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

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

  639.                     //CFRelease(UID);

  640.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  641.                 }

  642.             }

  643.             

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

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

  646.                 if (UID) {

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

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

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

  650.                     //CFRelease(UID);

  651.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  652.                 }

  653.             }

  654.             

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

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

  657.         } else {

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

  659.         }

  660.     }

  661.     */

  662.     

  663.     //-------------------------------------------------

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

  665.     //-------------------------------------------------

  666.     

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

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

  669.     

  670.     vector<CFStringRef> captureDeviceUID;

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

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

  673.         if (ref == NULL)

  674.             return -1;

  675.         captureDeviceUID.push_back(ref);

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

  677.         CFArrayAppendValue(subDevicesArray, ref);

  678.    }

  679.     

  680.     vector<CFStringRef> playbackDeviceUID;

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

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

  683.         if (ref == NULL)

  684.             return -1;

  685.         playbackDeviceUID.push_back(ref);

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

  687.         CFArrayAppendValue(subDevicesArray, ref);

  688.     }

  689.   

  690.     //-----------------------------------------------------------------------

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

  692.     //-----------------------------------------------------------------------

  693.  

  694.     AudioObjectPropertyAddress pluginAOPA;

  695.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  696.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  697.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  698.     UInt32 outDataSize;

  699. 

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

  701.     if (osErr != noErr) {

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

  703.         printError(osErr);

  704.         goto error;

  705.     }

  706.     

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

  708.     if (osErr != noErr) {

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

  710.         printError(osErr);

  711.         goto error;

  712.     }

  713. 

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

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

  716.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  717. 

  718.     //-------------------------

  719.     // Set the sub-device list

  720.     //-------------------------

  721. 

  722.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  723.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  724.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  725.     outDataSize = sizeof(CFMutableArrayRef);

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

  727.     if (osErr != noErr) {

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

  729.         printError(osErr);

  730.         goto error;

  731.     }

  732.     

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

  734.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  735.     

  736.     //-----------------------

  737.     // Set the master device

  738.     //-----------------------

  739. 

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

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

  742.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  743.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  744.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  745.     outDataSize = sizeof(CFStringRef);

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

  747.     if (osErr != noErr) {

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

  749.         printError(osErr);

  750.         goto error;

  751.     }

  752.     

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

  754.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  755.   

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

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

  758.     

  759.     if (fClockDriftCompensate) {

  760.         if (need_clock_drift_compensation) {

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

  762.        

  763.             // Get the property data size

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

  765.             if (osErr != noErr) {

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

  767.                 printError(osErr);

  768.             }

  769.             

  770.             //	Calculate the number of object IDs

  771.             subDevicesNum = outSize / sizeof(AudioObjectID);

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

  773.             AudioObjectID subDevices[subDevicesNum];

  774.             outSize = sizeof(subDevices);

  775.             

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

  777.             if (osErr != noErr) {

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

  779.                 printError(osErr);

  780.             }

  781.             

  782.             // Set kAudioSubDevicePropertyDriftCompensation property...

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

  784.                 UInt32 theDriftCompensationValue = 1;

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

  786.                 if (osErr != noErr) {

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

  788.                     printError(osErr);

  789.                 }

  790.             }

  791.         } else {

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

  793.         }

  794.     }    

  795.     

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

  797.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  798.        

  799.     //----------

  800.     // Clean up

  801.     //----------

  802.     

  803.     // release the private AD key

  804.     CFRelease(AggregateDeviceNumberRef);

  805. 

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

  807.     CFRelease(aggDeviceDict);

  808.     CFRelease(subDevicesArray);

  809.     

  810.     if (subDevicesArrayClock)

  811.         CFRelease(subDevicesArrayClock);

  812. 

  813.     // release the device UID

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

  815.         CFRelease(captureDeviceUID[i]);

  816.     }

  817.     

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

  819.         CFRelease(playbackDeviceUID[i]);

  820.     }

  821.     

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

  823.     return noErr;

  824.     

  825. error:

  826.     DestroyAggregateDevice();

  827.     return -1;

  828. }

  829. 

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

  831.                                       const char* playback_driver_uid, 

  832.                                       char* capture_driver_name, 

  833.                                       char* playback_driver_name, 

  834.                                       jack_nframes_t samplerate)

  835. {

  836.     capture_driver_name[0] = 0;

  837.     playback_driver_name[0] = 0;

  838.    

  839.     // Duplex

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

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

  842.           

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

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

  845.             

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

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

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

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

  850.                     return -1;

  851.                 }

  852.             }

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

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

  855.                 return -1;

  856.             }

  857.             

  858.         } else {

  859.         

  860.             // Creates aggregate device

  861.             AudioDeviceID captureID, playbackID;

  862.             

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

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

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

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

  867.                     return -1;

  868.                 }

  869.             }

  870. 

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

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

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

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

  875.                     return -1;

  876.                 }

  877.             }

  878. 

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

  880.                 return -1;

  881.         }

  882. 

  883.     // Capture only

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

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

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

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

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

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

  890.                 return -1;

  891.             }

  892.         }

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

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

  895.             return -1;

  896.         }

  897. 

  898.     // Playback only

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

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

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

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

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

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

  905.                 return -1;

  906.             }

  907.         }

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

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

  910.             return -1;

  911.         }

  912. 

  913.     // Use default driver in duplex mode

  914.     } else {

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

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

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

  918.             return -1;

  919.         }

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

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

  922.             return -1;

  923.         }

  924.     }

  925.     

  926.     if (fHogged) {

  927.         if (TakeHog()) {

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

  929.         } else {

  930.             jack_error("Cannot hog device = %ld", fDeviceID);

  931.         }

  932.     }

  933. 

  934.     return 0;

  935. }

  936. 

  937. /*

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

  939. */

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

  941. {

  942.     OSStatus err = noErr;

  943. 

  944.     if (capturing) {

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

  946.         if (err != noErr) {

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

  948.             printError(err);

  949.             return -1;

  950.         } else {

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

  952.         }

  953.     }

  954. 

  955.     if (playing) {

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

  957.         if (err != noErr) {

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

  959.             printError(err);

  960.             return -1;

  961.         } else {

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

  963.         }

  964.     }

  965. 

  966.     if (inchannels > in_nChannels) {

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

  968.         if (strict)

  969.             return -1;

  970.     }

  971. 

  972.     if (outchannels > out_nChannels) {

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

  974.         if (strict)

  975.             return -1;

  976.     }

  977. 

  978.     if (inchannels == -1) {

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

  980.         inchannels = in_nChannels;

  981.     }

  982. 

  983.     if (outchannels == -1) {

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

  985.         outchannels = out_nChannels;

  986.     }

  987. 

  988.     return 0;

  989. }

  990. 

  991. int JackCoreAudioDriver::SetupBufferSize(jack_nframes_t buffer_size)

  992. {

  993.     // Setting buffer size

  994.     UInt32 outSize = sizeof(UInt32);

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

  996.     if (err != noErr) {

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

  998.         printError(err);

  999.         return -1;

  1000.     }

  1001. 

  1002.     return 0;

  1003. }

  1004. 

  1005. int JackCoreAudioDriver::SetupSampleRate(jack_nframes_t samplerate)

  1006. {

  1007.     return SetupSampleRateAux(fDeviceID, samplerate);

  1008. }

  1009. 

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

  1011. {

  1012.     OSStatus err = noErr;

  1013.     UInt32 outSize;

  1014.     Float64 sampleRate;

  1015. 

  1016.     // Get sample rate

  1017.     outSize =  sizeof(Float64);

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

  1019.     if (err != noErr) {

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

  1021.         printError(err);

  1022.         return -1;

  1023.     }

  1024. 

  1025.     // If needed, set new sample rate

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

  1027.         sampleRate = (Float64)samplerate;

  1028. 

  1029.         // To get SR change notification

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

  1031.         if (err != noErr) {

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

  1033.             printError(err);

  1034.             return -1;

  1035.         }

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

  1037.         if (err != noErr) {

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

  1039.             printError(err);

  1040.             return -1;

  1041.         }

  1042. 

  1043.         // Waiting for SR change notification

  1044.         int count = 0;

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

  1046.             usleep(100000);

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

  1048.         }

  1049. 

  1050.         // Remove SR change notification

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

  1052.     }

  1053. 

  1054.     return 0;

  1055. }

  1056. 

  1057. int JackCoreAudioDriver::OpenAUHAL(bool capturing,

  1058.                                    bool playing,

  1059.                                    int inchannels,

  1060.                                    int outchannels,

  1061.                                    int in_nChannels,

  1062.                                    int out_nChannels,

  1063.                                    jack_nframes_t buffer_size,

  1064.                                    jack_nframes_t samplerate)

  1065. {

  1066.     ComponentResult err1;

  1067.     UInt32 enableIO;

  1068.     AudioStreamBasicDescription srcFormat, dstFormat;

  1069.     AudioDeviceID currAudioDeviceID;

  1070.     UInt32 size;

  1071. 

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

  1073. 

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

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

  1076.         return -1;

  1077.     }

  1078.          

  1079.     // AUHAL

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

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

  1082. 

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

  1084.     if (err1 != noErr) {

  1085.         jack_error("Error calling OpenAComponent");

  1086.         printError(err1);

  1087.         goto error;

  1088.     }

  1089. 

  1090.     err1 = AudioUnitInitialize(fAUHAL);

  1091.     if (err1 != noErr) {

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

  1093.         printError(err1);

  1094.         goto error;

  1095.     }

  1096. 

  1097.     // Start I/O

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

  1099.         enableIO = 1;

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

  1101.     } else {

  1102.         enableIO = 0;

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

  1104.     }

  1105.     

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

  1107.     if (err1 != noErr) {

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

  1109.         printError(err1);

  1110.         goto error;

  1111.     }

  1112. 

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

  1114.         enableIO = 1;

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

  1116.     } else {

  1117.         enableIO = 0;

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

  1119.     }

  1120.     

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

  1122.     if (err1 != noErr) {

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

  1124.         printError(err1);

  1125.         goto error;

  1126.     }

  1127.     

  1128.     size = sizeof(AudioDeviceID);

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

  1130.     if (err1 != noErr) {

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

  1132.         printError(err1);

  1133.         goto error;

  1134.     } else {

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

  1136.     }

  1137. 

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

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

  1140.     if (err1 != noErr) {

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

  1142.         printError(err1);

  1143.         goto error;

  1144.     }

  1145.   

  1146.     // Set buffer size

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

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

  1149.         if (err1 != noErr) {

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

  1151.             printError(err1);

  1152.             goto error;

  1153.         }

  1154.     }

  1155. 

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

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

  1158.         if (err1 != noErr) {

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

  1160.             printError(err1);

  1161.             goto error;

  1162.         }

  1163.     }

  1164. 

  1165.     // Setup channel map

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

  1167.         SInt32 chanArr[in_nChannels];

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

  1169.             chanArr[i] = -1;

  1170.         }

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

  1172.             chanArr[i] = i;

  1173.         }

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

  1175.         if (err1 != noErr) {

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

  1177.             printError(err1);

  1178.             goto error;

  1179.         }

  1180.     }

  1181. 

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

  1183.         SInt32 chanArr[out_nChannels];

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

  1185.             chanArr[i] = -1;

  1186.         }

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

  1188.             chanArr[i] = i;

  1189.         }

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

  1191.         if (err1 != noErr) {

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

  1193.             printError(err1);

  1194.             goto error;

  1195.         }

  1196.     }

  1197. 

  1198.     // Setup stream converters

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

  1200.     

  1201.         size = sizeof(AudioStreamBasicDescription);

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

  1203.         if (err1 != noErr) {

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

  1205.             printError(err1);

  1206.             goto error;

  1207.         }

  1208.         PrintStreamDesc(&srcFormat);

  1209.               

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

  1211.         srcFormat.mSampleRate = samplerate;

  1212.         srcFormat.mFormatID = kAudioFormatLinearPCM;

  1213.         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1214.         srcFormat.mBytesPerPacket = sizeof(float);

  1215.         srcFormat.mFramesPerPacket = 1;

  1216.         srcFormat.mBytesPerFrame = sizeof(float);

  1217.         srcFormat.mChannelsPerFrame = inchannels;

  1218.         srcFormat.mBitsPerChannel = 32;

  1219.         PrintStreamDesc(&srcFormat);

  1220.       

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

  1222.         

  1223.         if (err1 != noErr) {

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

  1225.             printError(err1);

  1226.             goto error;

  1227.         }

  1228.     }

  1229. 

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

  1231.     

  1232.         size = sizeof(AudioStreamBasicDescription);

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

  1234.         if (err1 != noErr) {

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

  1236.             printError(err1);

  1237.             goto error;

  1238.         }

  1239.         PrintStreamDesc(&dstFormat);

  1240.          

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

  1242.         dstFormat.mSampleRate = samplerate;

  1243.         dstFormat.mFormatID = kAudioFormatLinearPCM;

  1244.         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1245.         dstFormat.mBytesPerPacket = sizeof(float);

  1246.         dstFormat.mFramesPerPacket = 1;

  1247.         dstFormat.mBytesPerFrame = sizeof(float);

  1248.         dstFormat.mChannelsPerFrame = outchannels;

  1249.         dstFormat.mBitsPerChannel = 32;

  1250.         PrintStreamDesc(&dstFormat);

  1251.        

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

  1253.         

  1254.         if (err1 != noErr) {

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

  1256.             printError(err1);

  1257.             goto error;

  1258.         }

  1259.     }

  1260. 

  1261.     // Setup callbacks

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

  1263.         AURenderCallbackStruct output;

  1264.         output.inputProc = Render;

  1265.         output.inputProcRefCon = this;

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

  1267.         if (err1 != noErr) {

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

  1269.             printError(err1);

  1270.             goto error;

  1271.         }

  1272.     } else {

  1273.         AURenderCallbackStruct output;

  1274.         output.inputProc = Render;

  1275.         output.inputProcRefCon = this;

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

  1277.         if (err1 != noErr) {

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

  1279.             printError(err1);

  1280.             goto error;

  1281.         }

  1282.     }

  1283. 

  1284.     return 0;

  1285.     

  1286. error:

  1287.     CloseAUHAL();

  1288.     return -1;

  1289. }

  1290. 

  1291. int JackCoreAudioDriver::SetupBuffers(int inchannels)

  1292. {

  1293.     // Prepare buffers

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

  1295.     fJackInputData->mNumberBuffers = inchannels;

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

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

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

  1299.     }

  1300.     return 0;

  1301. }

  1302. 

  1303. void JackCoreAudioDriver::DisposeBuffers()

  1304. {

  1305.     if (fJackInputData) {

  1306.         free(fJackInputData);

  1307.         fJackInputData = 0;

  1308.     }

  1309. }

  1310. 

  1311. void JackCoreAudioDriver::CloseAUHAL()

  1312. {

  1313.     AudioUnitUninitialize(fAUHAL);

  1314.     CloseComponent(fAUHAL);

  1315. }

  1316. 

  1317. int JackCoreAudioDriver::AddListeners()

  1318. {

  1319.     OSStatus err = noErr;

  1320. 

  1321.     // Add listeners

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

  1323.     if (err != noErr) {

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

  1325.         printError(err);

  1326.         return -1;

  1327.     }

  1328. 

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

  1330.     if (err != noErr) {

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

  1332.         printError(err);

  1333.         return -1;

  1334.     }

  1335. 

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

  1337.     if (err != noErr) {

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

  1339.         printError(err);

  1340.         return -1;

  1341.     }

  1342. 

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

  1344.     if (err != noErr) {

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

  1346.         printError(err);

  1347.         return -1;

  1348.     }

  1349. 

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

  1351.     if (err != noErr) {

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

  1353.         printError(err);

  1354.         return -1;

  1355.     }

  1356. 

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

  1358.     if (err != noErr) {

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

  1360.         printError(err);

  1361.         return -1;

  1362.     }

  1363. 

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

  1365.         UInt32 outSize = sizeof(float);

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

  1367.         if (err != noErr) {

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

  1369.             printError(err);

  1370.         }

  1371.     }

  1372. 

  1373.     return 0;

  1374. }

  1375. 

  1376. void JackCoreAudioDriver::RemoveListeners()

  1377. {

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

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

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

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

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

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

  1384. }

  1385. 

  1386. int JackCoreAudioDriver::Open(jack_nframes_t buffer_size,

  1387.                               jack_nframes_t samplerate,

  1388.                               bool capturing,

  1389.                               bool playing,

  1390.                               int inchannels,

  1391.                               int outchannels,

  1392.                               bool monitor,

  1393.                               const char* capture_driver_uid,

  1394.                               const char* playback_driver_uid,

  1395.                               jack_nframes_t capture_latency,

  1396.                               jack_nframes_t playback_latency,

  1397.                               int async_output_latency,

  1398.                               int computation_grain,

  1399.                               bool hogged,

  1400.                               bool clock_drift)

  1401. {

  1402.     int in_nChannels = 0;

  1403.     int out_nChannels = 0;

  1404.     char capture_driver_name[256];

  1405.     char playback_driver_name[256];

  1406. 

  1407.     // Keep initial state

  1408.     fCapturing = capturing;

  1409.     fPlaying = playing;

  1410.     fInChannels = inchannels;

  1411.     fOutChannels = outchannels;

  1412.     fMonitor = monitor;

  1413.     strcpy(fCaptureUID, capture_driver_uid);

  1414.     strcpy(fPlaybackUID, playback_driver_uid);

  1415.     fCaptureLatency = capture_latency;

  1416.     fPlaybackLatency = playback_latency;

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

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

  1419.     fHogged = hogged;

  1420.     fClockDriftCompensate = clock_drift;

  1421.     

  1422.     SInt32 major;

  1423.     SInt32 minor;

  1424.     Gestalt(gestaltSystemVersionMajor, &major);

  1425.     Gestalt(gestaltSystemVersionMinor, &minor);

  1426.     

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

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

  1429.         CFRunLoopRef theRunLoop = NULL;

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

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

  1432.         if (osErr != noErr) {

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

  1434.             printError(osErr);

  1435.         }

  1436.     }

  1437. 

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

  1439.         goto error;

  1440. 

  1441.     // Generic JackAudioDriver Open

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

  1443.         goto error;

  1444. 

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

  1446.         goto error;

  1447. 

  1448.     if (SetupBufferSize(buffer_size) < 0)

  1449.         goto error;

  1450.         

  1451.     if (SetupSampleRate(samplerate) < 0)

  1452.         goto error;

  1453.  

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

  1455.         goto error;

  1456. 

  1457.     if (capturing && inchannels > 0)

  1458.         if (SetupBuffers(inchannels) < 0)

  1459.             goto error;

  1460. 

  1461.     if (AddListeners() < 0)

  1462.         goto error;

  1463.   

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

  1465.     fCaptureChannels = inchannels;

  1466.     fPlaybackChannels = outchannels;

  1467.     return noErr;

  1468. 

  1469. error:

  1470.     Close();

  1471.     return -1;

  1472. }

  1473. 

  1474. int JackCoreAudioDriver::Close()

  1475. {

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

  1477.     Stop();

  1478.     JackAudioDriver::Close();

  1479.     RemoveListeners();

  1480.     DisposeBuffers();

  1481.     CloseAUHAL();

  1482.     DestroyAggregateDevice();

  1483.     return 0;

  1484. }

  1485. 

  1486. int JackCoreAudioDriver::Attach()

  1487. {

  1488.     OSStatus err;

  1489.     JackPort* port;

  1490.     jack_port_id_t port_index;

  1491.     UInt32 size;

  1492.     Boolean isWritable;

  1493.     char channel_name[64];

  1494.     char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  1495.     char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  1496.     unsigned long port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  1497. 

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

  1499. 

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

  1501. 

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

  1503.         if (err != noErr)

  1504.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

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

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

  1507.             if (err != noErr)

  1508.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

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

  1510.         } else {

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

  1512.         }

  1513. 

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

  1515. 

  1516.         if ((port_index = fGraphManager->AllocatePort(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, (JackPortFlags)port_flags, fEngineControl->fBufferSize)) == NO_PORT) {

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

  1518.             return -1;

  1519.         }

  1520. 

  1521.         size = sizeof(UInt32);

  1522.         UInt32 value1 = 0;

  1523.         UInt32 value2 = 0;

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

  1525.         if (err != noErr)

  1526.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

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

  1528.         if (err != noErr)

  1529.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  1530. 

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

  1532.         port->SetAlias(alias);

  1533.         port->SetLatency(fEngineControl->fBufferSize + value1 + value2 + fCaptureLatency);

  1534.         fCapturePortList[i] = port_index;

  1535.     }

  1536. 

  1537.     port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  1538. 

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

  1540. 

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

  1542.         if (err != noErr)

  1543.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

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

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

  1546.             if (err != noErr)

  1547.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

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

  1549.         } else {

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

  1551.         }

  1552. 

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

  1554. 

  1555.         if ((port_index = fGraphManager->AllocatePort(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, (JackPortFlags)port_flags, fEngineControl->fBufferSize)) == NO_PORT) {

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

  1557.             return -1;

  1558.         }

  1559. 

  1560.         size = sizeof(UInt32);

  1561.         UInt32 value1 = 0;

  1562.         UInt32 value2 = 0;

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

  1564.         if (err != noErr)

  1565.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

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

  1567.         if (err != noErr)

  1568.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  1569. 

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

  1571.         port->SetAlias(alias);

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

  1573.         port->SetLatency(fEngineControl->fBufferSize + ((fEngineControl->fSyncMode) ? 0 : fEngineControl->fBufferSize * fIOUsage) + value1 + value2 + fPlaybackLatency);

  1574.         fPlaybackPortList[i] = port_index;

  1575. 

  1576.         // Monitor ports

  1577.         if (fWithMonitorPorts) {

  1578.             jack_log("Create monitor port ");

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

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

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

  1582.                 return -1;

  1583.             } else {

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

  1585.                 port->SetAlias(alias);

  1586.                 port->SetLatency(fEngineControl->fBufferSize);

  1587.                 fMonitorPortList[i] = port_index;

  1588.             }

  1589.         }

  1590.     }

  1591. 

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

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

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

  1595.     }

  1596. 

  1597.     return 0;

  1598. }

  1599. 

  1600. int JackCoreAudioDriver::Start()

  1601. {

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

  1603.     JackAudioDriver::Start();

  1604. /*

  1605. #ifdef MAC_OS_X_VERSION_10_5

  1606.     OSStatus err = AudioDeviceCreateIOProcID(fDeviceID, MeasureCallback, this, &fMesureCallbackID);

  1607. #else

  1608.     OSStatus err = AudioDeviceAddIOProc(fDeviceID, MeasureCallback, this);

  1609. #endif

  1610. */

  1611.     OSStatus err = AudioDeviceAddIOProc(fDeviceID, MeasureCallback, this);

  1612.     

  1613.     if (err != noErr)

  1614.         return -1;

  1615. 

  1616.     err = AudioOutputUnitStart(fAUHAL);

  1617.     if (err != noErr)

  1618.         return -1;

  1619. 

  1620.     if ((err = AudioDeviceStart(fDeviceID, MeasureCallback)) != noErr) {

  1621.         jack_error("Cannot start MeasureCallback");

  1622.         printError(err);

  1623.         return -1;

  1624.     }

  1625.     

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

  1627.     fState = false;

  1628.     int count = 0;

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

  1630.         usleep(100000);

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

  1632.     }

  1633.     

  1634.     if (count < WAIT_COUNTER) {

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

  1636.         return 0;

  1637.     } else {

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

  1639.         return -1;

  1640.     }

  1641. }

  1642. 

  1643. int JackCoreAudioDriver::Stop()

  1644. {

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

  1646.     AudioDeviceStop(fDeviceID, MeasureCallback);

  1647. /*

  1648. #ifdef MAC_OS_X_VERSION_10_5

  1649.     AudioDeviceDestroyIOProcID(fDeviceID, fMesureCallbackID);

  1650. #else

  1651.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

  1652. #endif

  1653. */

  1654.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

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

  1656. }

  1657. 

  1658. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  1659. {

  1660.     OSStatus err;

  1661.     UInt32 outSize = sizeof(UInt32);

  1662. 

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

  1664.     if (err != noErr) {

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

  1666.         printError(err);

  1667.         return -1;

  1668.     }

  1669. 

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

  1671. 

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

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

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

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

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

  1677.     }

  1678. 

  1679.     return 0;

  1680. }

  1681. 

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

  1683. {

  1684.     pid_t hog_pid;

  1685.     OSStatus err;

  1686. 

  1687.     UInt32 propSize = sizeof(hog_pid);

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

  1689.     if (err) {

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

  1691.         printError(err);

  1692.     }

  1693. 

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

  1695.         hog_pid = getpid();

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

  1697.         if (err != noErr) {

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

  1699.             return false;

  1700.         }

  1701.     }

  1702.     

  1703.     return true;

  1704. }

  1705.     

  1706. bool JackCoreAudioDriver::TakeHog()

  1707. {

  1708.     OSStatus err = noErr;

  1709.     AudioObjectID sub_device[32];

  1710.     UInt32 outSize = sizeof(sub_device);

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

  1712.     

  1713.     if (err != noErr) {

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

  1715.         return TakeHogAux(fDeviceID, true);

  1716.     } else {

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

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

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

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

  1721.                 return false;

  1722.             }

  1723.         }

  1724.         return true;

  1725.     }

  1726. }

  1727.     

  1728. bool JackCoreAudioDriver::IsAggregateDevice(AudioDeviceID device)

  1729. {

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

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

  1732.     

  1733.     if (err != noErr) {

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

  1735.         return false;

  1736.     } else {

  1737.         return (deviceType == kAudioDeviceTransportTypeAggregate);

  1738.     }

  1739. }

  1740. 

  1741. 

  1742. } // end of namespace

  1743. 

  1744. 

  1745. #ifdef __cplusplus

  1746. extern "C"

  1747. {

  1748. #endif

  1749. 

  1750.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor() 

  1751.     {

  1752.         jack_driver_desc_t *desc;

  1753.         unsigned int i;

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

  1755. 

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

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

  1758.         

  1759.         desc->nparams = 17;

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

  1761. 

  1762.         i = 0;

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

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

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

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

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

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

  1769. 

  1770.         i++;

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

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

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

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

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

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

  1777. 

  1778.         i++;

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

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

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

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

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

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

  1785. 

  1786.         i++;

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

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

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

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

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

  1792. 

  1793.         i++;

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

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

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

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

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

  1799. 

  1800.         i++;

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

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

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

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

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

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

  1807. 

  1808.         i++;

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

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

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

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

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

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

  1815. 

  1816.         i++;

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

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

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

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

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

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

  1823. 

  1824.         i++;

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

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

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

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

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

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

  1831. 

  1832.         i++;

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

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

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

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

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

  1838. 

  1839.         i++;

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

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

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

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

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

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

  1846. 

  1847.         i++;

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

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

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

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

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

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

  1854. 

  1855.         i++;

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

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

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

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

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

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

  1862.         

  1863.         i++;

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

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

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

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

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

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

  1870.         

  1871.         i++;

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

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

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

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

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

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

  1878.         

  1879.         i++;

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

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

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

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

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

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

  1886.         

  1887.         i++;

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

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

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

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

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

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

  1894. 

  1895.         return desc;

  1896.     }

  1897. 

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

  1899.     {

  1900.         jack_nframes_t srate = 44100;

  1901.         jack_nframes_t frames_per_interrupt = 128;

  1902.         bool capture = false;

  1903.         bool playback = false;

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

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

  1906.         bool monitor = false;

  1907.         const char* capture_driver_uid = "";

  1908.         const char* playback_driver_uid = "";

  1909.         const JSList *node;

  1910.         const jack_driver_param_t *param;

  1911.         jack_nframes_t systemic_input_latency = 0;

  1912.         jack_nframes_t systemic_output_latency = 0;

  1913.         int async_output_latency = 100;

  1914.         int computation_grain = -1;

  1915.         bool hogged = false;

  1916.         bool clock_drift = false;

  1917.     

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

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

  1920.        

  1921.             switch (param->character) {

  1922. 

  1923.                 case 'd':

  1924.                     capture_driver_uid = strdup(param->value.str);

  1925.                     playback_driver_uid = strdup(param->value.str);

  1926.                     break;

  1927. 

  1928.                 case 'D':

  1929.                     capture = true;

  1930.                     playback = true;

  1931.                     break;

  1932. 

  1933.                 case 'c':

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

  1935.                     break;

  1936. 

  1937.                 case 'i':

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

  1939.                     break;

  1940. 

  1941.                 case 'o':

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

  1943.                     break;

  1944. 

  1945.                 case 'C':

  1946.                     capture = true;

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

  1948.                         capture_driver_uid = strdup(param->value.str);

  1949.                     }

  1950.                     break;

  1951. 

  1952.                 case 'P':

  1953.                     playback = true;

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

  1955.                         playback_driver_uid = strdup(param->value.str);

  1956.                     }

  1957.                     break;

  1958. 

  1959.                 case 'm':

  1960.                     monitor = param->value.i;

  1961.                     break;

  1962. 

  1963.                 case 'r':

  1964.                     srate = param->value.ui;

  1965.                     break;

  1966. 

  1967.                 case 'p':

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

  1969.                     break;

  1970. 

  1971.                 case 'I':

  1972.                     systemic_input_latency = param->value.ui;

  1973.                     break;

  1974. 

  1975.                 case 'O':

  1976.                     systemic_output_latency = param->value.ui;

  1977.                     break;

  1978. 

  1979.                 case 'l':

  1980.                     Jack::DisplayDeviceNames();

  1981.                     break;

  1982.                     

  1983.                 case 'H':

  1984.                     hogged = true;

  1985.                     break;

  1986.                     

  1987.                 case 'L':

  1988.                     async_output_latency = param->value.ui;

  1989.                     break;

  1990.                     

  1991.                 case 'G':

  1992.                     computation_grain = param->value.ui;

  1993.                     break;

  1994.                     

  1995.                 case 's':

  1996.                     clock_drift = true;

  1997.                     break;

  1998.             }

  1999.         }

  2000. 

  2001.         /* duplex is the default */

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

  2003.             capture = true;

  2004.             playback = true;

  2005.         }

  2006. 

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

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

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

  2010.             return driver;

  2011.         } else {

  2012.             delete driver;

  2013.             return NULL;

  2014.         }

  2015.     }

  2016. 

  2017. #ifdef __cplusplus

  2018. }

  2019. #endif

  2020.