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

1573 lines
59KB
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. 

  34. namespace Jack

  35. {

  36. 

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

  38. {

  39.     UInt32 __4CC_number = (c);

  40.     char __4CC_string[5];

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

  42.     __4CC_string[4] = 0;

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

  44. }

  45. 

  46. static void printError(OSStatus err)

  47. {

  48.     switch (err) {

  49.         case kAudioHardwareNoError:

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

  51.             break;

  52.         case kAudioConverterErr_FormatNotSupported:

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

  54.             break;

  55.         case kAudioConverterErr_OperationNotSupported:

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

  57.             break;

  58.         case kAudioConverterErr_PropertyNotSupported:

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

  60.             break;

  61.         case kAudioConverterErr_InvalidInputSize:

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

  63.             break;

  64.         case kAudioConverterErr_InvalidOutputSize:

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

  66.             break;

  67.         case kAudioConverterErr_UnspecifiedError:

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

  69.             break;

  70.         case kAudioConverterErr_BadPropertySizeError:

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

  72.             break;

  73.         case kAudioConverterErr_RequiresPacketDescriptionsError:

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

  75.             break;

  76.         case kAudioConverterErr_InputSampleRateOutOfRange:

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

  78.             break;

  79.         case kAudioConverterErr_OutputSampleRateOutOfRange:

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

  81.             break;

  82.         case kAudioHardwareNotRunningError:

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

  84.             break;

  85.         case kAudioHardwareUnknownPropertyError:

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

  87.             break;

  88.         case kAudioHardwareIllegalOperationError:

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

  90.             break;

  91.         case kAudioHardwareBadDeviceError:

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

  93.             break;

  94.         case kAudioHardwareBadStreamError:

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

  96.             break;

  97.         case kAudioDeviceUnsupportedFormatError:

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

  99.             break;

  100.         case kAudioDevicePermissionsError:

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

  102.             break;

  103.         case kAudioHardwareBadObjectError:

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

  105.             break;

  106.         case kAudioHardwareUnsupportedOperationError:

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

  108.             break;

  109.         default:

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

  111.             break;

  112.     }

  113. }

  114. 

  115. static OSStatus DisplayDeviceNames()

  116. {

  117.     UInt32 size;

  118.     Boolean isWritable;

  119.     int i, deviceNum;

  120.     OSStatus err;

  121.     CFStringRef UIname;

  122. 

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

  124.     if (err != noErr)

  125.         return err;

  126. 

  127.     deviceNum = size / sizeof(AudioDeviceID);

  128.     AudioDeviceID devices[deviceNum];

  129. 

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

  131.     if (err != noErr)

  132.         return err;

  133. 

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

  135.         char device_name[256];

  136.         char internal_name[256];

  137. 

  138.         size = sizeof(CFStringRef);

  139.         UIname = NULL;

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

  141.         if (err == noErr) {

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

  143.         } else {

  144.             goto error;

  145.         }

  146. 

  147.         size = 256;

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

  149.         if (err != noErr)

  150.             return err;

  151. 

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

  153.     }

  154. 

  155.     return noErr;

  156. 

  157. error:

  158.     if (UIname != NULL)

  159.         CFRelease(UIname);

  160.     return err;

  161. }

  162. 

  163. static CFStringRef GetDeviceName(AudioDeviceID id)

  164. {

  165.     UInt32 size = sizeof(CFStringRef);

  166.     CFStringRef UIname;

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

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

  169. }

  170. 

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

  172.                                      AudioUnitRenderActionFlags *ioActionFlags,

  173.                                      const AudioTimeStamp *inTimeStamp,

  174.                                      UInt32 inBusNumber,

  175.                                      UInt32 inNumberFrames,

  176.                                      AudioBufferList *ioData)

  177. {

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

  179.     driver->fActionFags = ioActionFlags;

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

  181.     driver->fDriverOutputData = ioData;

  182.     driver->CycleTakeBeginTime();

  183.     return driver->Process();

  184. }

  185. 

  186. int JackCoreAudioDriver::Read()

  187. {

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

  189.     return 0;

  190. }

  191. 

  192. int JackCoreAudioDriver::Write()

  193. {

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

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

  196.             float* buffer = GetOutputBuffer(i);

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

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

  199.             // Monitor ports

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

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

  202.         } else {

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

  204.         }

  205.     }

  206.     return 0;

  207. }

  208. 

  209. // Will run only once

  210. OSStatus JackCoreAudioDriver::MeasureCallback(AudioDeviceID inDevice,

  211.         const AudioTimeStamp* inNow,

  212.         const AudioBufferList* inInputData,

  213.         const AudioTimeStamp* inInputTime,

  214.         AudioBufferList* outOutputData,

  215.         const AudioTimeStamp* inOutputTime,

  216.         void* inClientData)

  217. {

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

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

  220.     

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

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

  223.     

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

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

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

  227.     }

  228.     

  229.     // Setup threadded based log function

  230.     set_threaded_log_function();

  231.     return noErr;

  232. }

  233. 

  234. OSStatus JackCoreAudioDriver::SRNotificationCallback(AudioDeviceID inDevice,

  235.         UInt32 inChannel,

  236.         Boolean	isInput,

  237.         AudioDevicePropertyID inPropertyID,

  238.         void* inClientData)

  239. {

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

  241. 

  242.     switch (inPropertyID) {

  243. 

  244.         case kAudioDevicePropertyNominalSampleRate: {

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

  246.             driver->fState = true;

  247.             break;

  248.         }

  249.     }

  250. 

  251.     return noErr;

  252. }

  253. 

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

  255. OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,

  256.         UInt32 inChannel,

  257.         Boolean	isInput,

  258.         AudioDevicePropertyID inPropertyID,

  259.         void* inClientData)

  260. {

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

  262.          

  263.     switch (inPropertyID) {

  264.         

  265.         case kAudioDeviceProcessorOverload: {

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

  267.             jack_time_t cur_time = GetMicroSeconds();

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

  269.             break;

  270.         }

  271.         

  272.         case kAudioDevicePropertyStreamConfiguration: {

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

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

  275.             driver->CloseAUHAL();

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

  277.             return kAudioHardwareUnsupportedOperationError;

  278.         }

  279.         

  280.         case kAudioDevicePropertyNominalSampleRate: {

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

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

  283.             driver->CloseAUHAL();

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

  285.             return kAudioHardwareUnsupportedOperationError;

  286. 		}

  287.             

  288.     }

  289.     return noErr;

  290. }

  291. 

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

  293. {

  294.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  297. 

  298.     if (inIUD == NULL) {

  299.         return kAudioHardwareUnspecifiedError;

  300.     } else {

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

  302.         CFRelease(inIUD);

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

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

  305.     }

  306. }

  307. 

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

  309. {

  310.     OSStatus res;

  311.     UInt32 theSize = sizeof(UInt32);

  312.     AudioDeviceID inDefault;

  313.     AudioDeviceID outDefault;

  314. 

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

  316.         return res;

  317. 

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

  319.         return res;

  320. 

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

  322. 

  323.     // Get the device only if default input and ouput are the same

  324.     if (inDefault == outDefault) {

  325.         *id = inDefault;

  326.         return noErr;

  327.     } else {

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

  329.         return kAudioHardwareBadDeviceError;

  330.     }

  331. }

  332. 

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

  334. {

  335.     OSStatus res;

  336.     UInt32 theSize = sizeof(UInt32);

  337.     AudioDeviceID inDefault;

  338. 

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

  340.         return res;

  341. 

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

  343.     *id = inDefault;

  344.     return noErr;

  345. }

  346. 

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

  348. {

  349.     OSStatus res;

  350.     UInt32 theSize = sizeof(UInt32);

  351.     AudioDeviceID outDefault;

  352. 

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

  354.         return res;

  355. 

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

  357.     *id = outDefault;

  358.     return noErr;

  359. }

  360. 

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

  362. {

  363.     UInt32 size = 256;

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

  365. }

  366. 

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

  368. {

  369.     OSStatus err = noErr;

  370.     UInt32	outSize;

  371.     Boolean	outWritable;

  372.     AudioBufferList* bufferList = 0;

  373. 

  374.     channelCount = 0;

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

  376.     if (err == noErr) {

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

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

  379.         if (err == noErr) {

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

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

  382.         }

  383. 

  384.         if (bufferList)

  385.             free(bufferList);

  386.     }

  387. 

  388.     return err;

  389. }

  390. 

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

  392.         : JackAudioDriver(name, alias, engine, table), fJackInputData(NULL), fDriverOutputData(NULL), fState(false), fIOUsage(1.f),fComputationGrain(-1.f)

  393. {}

  394. 

  395. JackCoreAudioDriver::~JackCoreAudioDriver()

  396. {}

  397. 

  398. OSStatus JackCoreAudioDriver::CreateAggregateDevice(AudioDeviceID captureDeviceID, AudioDeviceID playbackDeviceID, AudioDeviceID* outAggregateDevice) 

  399. {

  400.     OSStatus osErr = noErr;

  401.     UInt32 outSize;

  402.     Boolean outWritable;

  403. 

  404.     //-----------------------

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

  406.     //-----------------------

  407. 

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

  409.     if (osErr != noErr) 

  410.         return osErr;

  411. 

  412.     AudioValueTranslation pluginAVT;

  413. 

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

  415.     AudioObjectID pluginID;

  416. 

  417.     pluginAVT.mInputData = &inBundleRef;

  418.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  419.     pluginAVT.mOutputData = &pluginID;

  420.     pluginAVT.mOutputDataSize = sizeof(pluginID);

  421. 

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

  423.     if (osErr != noErr) 

  424.         return osErr;

  425. 

  426.     //-----------------------

  427.     // Create a CFDictionary for our aggregate device

  428.     //-----------------------

  429. 

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

  431. 

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

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

  434. 

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

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

  437. 

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

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

  440. 

  441.     //-------------------------------------------------

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

  443.     //-------------------------------------------------

  444.     

  445.     CFStringRef captureDeviceUID = GetDeviceName(captureDeviceID);

  446.     CFStringRef playbackDeviceUID = GetDeviceName(playbackDeviceID);

  447.     

  448.     if (captureDeviceUID == NULL || playbackDeviceUID == NULL)

  449.         return -1;

  450.   

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

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

  453. 

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

  455.     CFArrayAppendValue(subDevicesArray, captureDeviceUID);

  456.     CFArrayAppendValue(subDevicesArray, playbackDeviceUID);

  457. 

  458.     //-----------------------------------------------------------------------

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

  460.     //-----------------------------------------------------------------------

  461.  

  462.     AudioObjectPropertyAddress pluginAOPA;

  463.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  464.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  465.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  466.     UInt32 outDataSize;

  467. 

  468.     osErr = AudioObjectGetPropertyDataSize(pluginID, &pluginAOPA, 0, NULL, &outDataSize);

  469.     if (osErr != noErr) 

  470.         return osErr;

  471. 

  472.     osErr = AudioObjectGetPropertyData(pluginID, &pluginAOPA, sizeof(aggDeviceDict), &aggDeviceDict, &outDataSize, outAggregateDevice);

  473.     if (osErr != noErr) 

  474.         return osErr;

  475. 

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

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

  478.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  479. 

  480.     //-------------------------

  481.     // Set the sub-device list

  482.     //-------------------------

  483. 

  484.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  485.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  486.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  487.     outDataSize = sizeof(CFMutableArrayRef);

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

  489.     if (osErr != noErr)

  490.         return osErr;

  491. 

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

  493.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  494. 

  495.     //-----------------------

  496.     // Set the master device

  497.     //-----------------------

  498. 

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

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

  501.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  502.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  503.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  504.     outDataSize = sizeof(CFStringRef);

  505.     osErr = AudioObjectSetPropertyData(*outAggregateDevice, &pluginAOPA, 0, NULL, outDataSize, &captureDeviceUID);  // capture is master...

  506.     if (osErr != noErr) 

  507.         return osErr;

  508. 

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

  510.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  511. 

  512.     //----------

  513.     // Clean up

  514.     //----------

  515. 

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

  517.     CFRelease(aggDeviceDict);

  518.     CFRelease(subDevicesArray);

  519. 

  520.     // release the device UID

  521.     CFRelease(captureDeviceUID);

  522.     CFRelease(playbackDeviceUID);

  523.     

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

  525.     return noErr;

  526. }

  527. 

  528. int JackCoreAudioDriver::SetupDevices(const char* capture_driver_uid, const char* playback_driver_uid, char* capture_driver_name, char* playback_driver_name)

  529. {

  530.     capture_driver_name[0] = 0;

  531.     playback_driver_name[0] = 0;

  532. 

  533.     // Duplex

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

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

  536.         

  537.         /*

  538.         AudioDeviceID captureID, playbackID;

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

  540.             return -1;

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

  542.             return -1;

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

  544.             return -1;

  545.         */

  546.         

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

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

  549.             

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

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

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

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

  554.                     return -1;

  555.                 }

  556.             }

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

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

  559.                 return -1;

  560.             }

  561.             

  562.         } else {

  563.         

  564.             // Creates agregate device

  565.             AudioDeviceID captureID, playbackID;

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

  567.                 return -1;

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

  569.                 return -1;

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

  571.                 return -1;

  572.         }

  573. 

  574.         // Capture only

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

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

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

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

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

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

  581.                 return -1;

  582.             }

  583.         }

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

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

  586.             return -1;

  587.         }

  588. 

  589.         // Playback only

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

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

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

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

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

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

  596.                 return -1;

  597.             }

  598.         }

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

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

  601.             return -1;

  602.         }

  603. 

  604.         // Use default driver in duplex mode

  605.     } else {

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

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

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

  609.             return -1;

  610.         }

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

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

  613.             return -1;

  614.         }

  615.     }

  616. 

  617.     return 0;

  618. }

  619. 

  620. /*

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

  622. */

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

  624. {

  625.     OSStatus err = noErr;

  626. 

  627.     if (capturing) {

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

  629.         if (err != noErr) {

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

  631.             printError(err);

  632.             return -1;

  633.         } else {

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

  635.         }

  636.     }

  637. 

  638.     if (playing) {

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

  640.         if (err != noErr) {

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

  642.             printError(err);

  643.             return -1;

  644.         } else {

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

  646.         }

  647.     }

  648. 

  649.     if (inchannels > in_nChannels) {

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

  651.         if (strict)

  652.             return -1;

  653.     }

  654. 

  655.     if (outchannels > out_nChannels) {

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

  657.         if (strict)

  658.             return -1;

  659.     }

  660. 

  661.     if (inchannels == 0) {

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

  663.         inchannels = in_nChannels;

  664.     }

  665. 

  666.     if (outchannels == 0) {

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

  668.         outchannels = out_nChannels;

  669.     }

  670. 

  671.     return 0;

  672. }

  673. 

  674. int JackCoreAudioDriver::SetupBufferSizeAndSampleRate(jack_nframes_t buffer_size, jack_nframes_t samplerate)

  675. {

  676.     OSStatus err = noErr;

  677.     UInt32 outSize;

  678.     Float64 sampleRate;

  679. 

  680.     // Setting buffer size

  681.     outSize = sizeof(UInt32);

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

  683.     if (err != noErr) {

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

  685.         printError(err);

  686.         return -1;

  687.     }

  688. 

  689.     // Get sample rate

  690.     outSize =  sizeof(Float64);

  691.     err = AudioDeviceGetProperty(fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);

  692.     if (err != noErr) {

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

  694.         printError(err);

  695.         return -1;

  696.     }

  697. 

  698.     // If needed, set new sample rate

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

  700.         sampleRate = (Float64)samplerate;

  701. 

  702.         // To get SR change notification

  703.         err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback, this);

  704.         if (err != noErr) {

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

  706.             printError(err);

  707.             return -1;

  708.         }

  709.         err = AudioDeviceSetProperty(fDeviceID, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, outSize, &sampleRate);

  710.         if (err != noErr) {

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

  712.             printError(err);

  713.             return -1;

  714.         }

  715. 

  716.         // Waiting for SR change notification

  717.         int count = 0;

  718.         while (!fState && count++ < 100) {

  719.             usleep(100000);

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

  721.         }

  722. 

  723.         // Remove SR change notification

  724.         AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback);

  725.     }

  726. 

  727.     return 0;

  728. }

  729. 

  730. int JackCoreAudioDriver::OpenAUHAL(bool capturing,

  731.                                    bool playing,

  732.                                    int inchannels,

  733.                                    int outchannels,

  734.                                    int in_nChannels,

  735.                                    int out_nChannels,

  736.                                    jack_nframes_t buffer_size,

  737.                                    jack_nframes_t samplerate,

  738.                                    bool strict)

  739. {

  740.     ComponentResult err1;

  741.     UInt32 enableIO;

  742.     AudioStreamBasicDescription srcFormat, dstFormat;

  743. 

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

  745. 

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

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

  748.         return -1;

  749.     }

  750.          

  751.     // AUHAL

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

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

  754. 

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

  756.     if (err1 != noErr) {

  757.         jack_error("Error calling OpenAComponent");

  758.         printError(err1);

  759.         return -1;

  760.     }

  761. 

  762.     err1 = AudioUnitInitialize(fAUHAL);

  763.     if (err1 != noErr) {

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

  765.         printError(err1);

  766.         return -1;

  767.     }

  768. 

  769.     // Start I/O

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

  771.         enableIO = 1;

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

  773.     } else {

  774.         enableIO = 0;

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

  776.     }

  777.     

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

  779.     if (err1 != noErr) {

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

  781.         printError(err1);

  782.         if (strict)

  783.             return -1;

  784.     }

  785. 

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

  787.         enableIO = 1;

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

  789.     } else {

  790.         enableIO = 0;

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

  792.     }

  793.     

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

  795.     if (err1 != noErr) {

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

  797.         printError(err1);

  798.         if (strict)

  799.             return -1;

  800.     }

  801.     

  802.     AudioDeviceID currAudioDeviceID;

  803.     UInt32 size = sizeof(AudioDeviceID);

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

  805.     if (err1 != noErr) {

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

  807.         printError(err1);

  808.         if (strict)

  809.             return -1;

  810.     } else {

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

  812.     }

  813. 

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

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

  816.     if (err1 != noErr) {

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

  818.         printError(err1);

  819.         if (strict)

  820.             return -1;

  821.     }

  822.     

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

  824.     if (err1 != noErr) {

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

  826.         printError(err1);

  827.         if (strict)

  828.             return -1;

  829.     } else {

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

  831.     }

  832. 

  833.     // Set buffer size

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

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

  836.         if (err1 != noErr) {

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

  838.             printError(err1);

  839.             if (strict)

  840.                 return -1;

  841.         }

  842.     }

  843. 

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

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

  846.         if (err1 != noErr) {

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

  848.             printError(err1);

  849.             if (strict)

  850.                 return -1;

  851.         }

  852.     }

  853. 

  854.     // Setup channel map

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

  856.         SInt32 chanArr[in_nChannels];

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

  858.             chanArr[i] = -1;

  859.         }

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

  861.             chanArr[i] = i;

  862.         }

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

  864.         if (err1 != noErr) {

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

  866.             printError(err1);

  867.         }

  868.     }

  869. 

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

  871.         SInt32 chanArr[out_nChannels];

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

  873.             chanArr[i] = -1;

  874.         }

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

  876.             chanArr[i] = i;

  877.         }

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

  879.         if (err1 != noErr) {

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

  881.             printError(err1);

  882.         }

  883.     }

  884. 

  885.     // Setup stream converters

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

  887.     srcFormat.mSampleRate = samplerate;

  888.     srcFormat.mFormatID = kAudioFormatLinearPCM;

  889.     srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  890.     srcFormat.mBytesPerPacket = sizeof(float);

  891.     srcFormat.mFramesPerPacket = 1;

  892.     srcFormat.mBytesPerFrame = sizeof(float);

  893.     srcFormat.mChannelsPerFrame = outchannels;

  894.     srcFormat.mBitsPerChannel = 32;

  895. 

  896.     err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &srcFormat, sizeof(AudioStreamBasicDescription));

  897.     if (err1 != noErr) {

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

  899.         printError(err1);

  900.     }

  901. 

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

  903.     dstFormat.mSampleRate = samplerate;

  904.     dstFormat.mFormatID = kAudioFormatLinearPCM;

  905.     dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  906.     dstFormat.mBytesPerPacket = sizeof(float);

  907.     dstFormat.mFramesPerPacket = 1;

  908.     dstFormat.mBytesPerFrame = sizeof(float);

  909.     dstFormat.mChannelsPerFrame = inchannels;

  910.     dstFormat.mBitsPerChannel = 32;

  911. 

  912.     err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &dstFormat, sizeof(AudioStreamBasicDescription));

  913.     if (err1 != noErr) {

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

  915.         printError(err1);

  916.     }

  917. 

  918.     // Setup callbacks

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

  920.         AURenderCallbackStruct output;

  921.         output.inputProc = Render;

  922.         output.inputProcRefCon = this;

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

  924.         if (err1 != noErr) {

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

  926.             printError(err1);

  927.             return -1;

  928.         }

  929.     } else {

  930.         AURenderCallbackStruct output;

  931.         output.inputProc = Render;

  932.         output.inputProcRefCon = this;

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

  934.         if (err1 != noErr) {

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

  936.             printError(err1);

  937.             return -1;

  938.         }

  939.     }

  940. 

  941.     return 0;

  942. }

  943. 

  944. int JackCoreAudioDriver::SetupBuffers(int inchannels)

  945. {

  946.     // Prepare buffers

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

  948.     if (fJackInputData == 0) {

  949.         jack_error("Cannot allocate memory for input buffers");

  950.         return -1;

  951.     }

  952.     fJackInputData->mNumberBuffers = inchannels;

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

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

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

  956.     }

  957.     return 0;

  958. }

  959. 

  960. void JackCoreAudioDriver::DisposeBuffers()

  961. {

  962.     if (fJackInputData) {

  963.         free(fJackInputData);

  964.         fJackInputData = 0;

  965.     }

  966. }

  967. 

  968. void JackCoreAudioDriver::CloseAUHAL()

  969. {

  970.     AudioUnitUninitialize(fAUHAL);

  971.     CloseComponent(fAUHAL);

  972. }

  973. 

  974. int JackCoreAudioDriver::AddListeners()

  975. {

  976.     OSStatus err = noErr;

  977. 

  978.     // Add listeners

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

  980.     if (err != noErr) {

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

  982.         printError(err);

  983.         return -1;

  984.     }

  985. 

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

  987.     if (err != noErr) {

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

  989.         printError(err);

  990.         return -1;

  991.     }

  992. 

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

  994.     if (err != noErr) {

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

  996.         printError(err);

  997.         return -1;

  998.     }

  999. 

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

  1001.     if (err != noErr) {

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

  1003.         printError(err);

  1004.         return -1;

  1005.     }

  1006. 

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

  1008.     if (err != noErr) {

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

  1010.         printError(err);

  1011.         return -1;

  1012.     }

  1013. 

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

  1015.     if (err != noErr) {

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

  1017.         printError(err);

  1018.         return -1;

  1019.     }

  1020. 

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

  1022.         UInt32 outSize = sizeof(float);

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

  1024.         if (err != noErr) {

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

  1026.             printError(err);

  1027.         }

  1028.     }

  1029. 

  1030.     return 0;

  1031. }

  1032. 

  1033. void JackCoreAudioDriver::RemoveListeners()

  1034. {

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

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

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

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

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

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

  1041. }

  1042. 

  1043. int JackCoreAudioDriver::Open(jack_nframes_t buffer_size,

  1044.                               jack_nframes_t samplerate,

  1045.                               bool capturing,

  1046.                               bool playing,

  1047.                               int inchannels,

  1048.                               int outchannels,

  1049.                               bool monitor,

  1050.                               const char* capture_driver_uid,

  1051.                               const char* playback_driver_uid,

  1052.                               jack_nframes_t capture_latency,

  1053.                               jack_nframes_t playback_latency,

  1054.                               int async_output_latency,

  1055.                               int computation_grain)

  1056. {

  1057.     int in_nChannels = 0;

  1058.     int out_nChannels = 0;

  1059.     char capture_driver_name[256];

  1060.     char playback_driver_name[256];

  1061. 

  1062.     // Keep initial state

  1063.     fCapturing = capturing;

  1064.     fPlaying = playing;

  1065.     fInChannels = inchannels;

  1066.     fOutChannels = outchannels;

  1067.     fMonitor = monitor;

  1068.     strcpy(fCaptureUID, capture_driver_uid);

  1069.     strcpy(fPlaybackUID, playback_driver_uid);

  1070.     fCaptureLatency = capture_latency;

  1071.     fPlaybackLatency = playback_latency;

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

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

  1074.     

  1075.     SInt32 major;

  1076.     SInt32 minor;

  1077.     Gestalt(gestaltSystemVersionMajor, &major);

  1078.     Gestalt(gestaltSystemVersionMinor, &minor);

  1079.     

  1080.     // Starting with 10.6 systems...

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

  1082.         CFRunLoopRef theRunLoop = NULL;

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

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

  1085.         if (theError != noErr) {

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

  1087.         }

  1088.     }

  1089. 

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

  1091.         return -1;

  1092. 

  1093.     // Generic JackAudioDriver Open

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

  1095.         return -1;

  1096. 

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

  1098.         return -1;

  1099. 

  1100.     if (SetupBufferSizeAndSampleRate(buffer_size, samplerate)  < 0)

  1101.         return -1;

  1102.  

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

  1104.         goto error;

  1105. 

  1106.     if (capturing && inchannels > 0)

  1107.         if (SetupBuffers(inchannels) < 0)

  1108.             goto error;

  1109. 

  1110.     if (AddListeners() < 0)

  1111.         goto error;

  1112. 

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

  1114.     fCaptureChannels = inchannels;

  1115.     fPlaybackChannels = outchannels;

  1116.     return noErr;

  1117. 

  1118. error:

  1119.     Close();

  1120.     return -1;

  1121. }

  1122. 

  1123. int JackCoreAudioDriver::Close()

  1124. {

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

  1126.     Stop();

  1127.     JackAudioDriver::Close();

  1128.     RemoveListeners();

  1129.     DisposeBuffers();

  1130.     CloseAUHAL();

  1131.     return 0;

  1132. }

  1133. 

  1134. int JackCoreAudioDriver::Attach()

  1135. {

  1136.     OSStatus err;

  1137.     JackPort* port;

  1138.     jack_port_id_t port_index;

  1139.     UInt32 size;

  1140.     Boolean isWritable;

  1141.     char channel_name[64];

  1142.     char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  1143.     char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

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

  1145. 

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

  1147. 

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

  1149. 

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

  1151.         if (err != noErr)

  1152.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

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

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

  1155.             if (err != noErr)

  1156.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

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

  1158.         } else {

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

  1160.         }

  1161. 

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

  1163. 

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

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

  1166.             return -1;

  1167.         }

  1168. 

  1169.         size = sizeof(UInt32);

  1170.         UInt32 value1 = 0;

  1171.         UInt32 value2 = 0;

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

  1173.         if (err != noErr)

  1174.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

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

  1176.         if (err != noErr)

  1177.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  1178. 

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

  1180.         port->SetAlias(alias);

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

  1182.         fCapturePortList[i] = port_index;

  1183.     }

  1184. 

  1185.     port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  1186. 

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

  1188. 

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

  1190.         if (err != noErr)

  1191.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

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

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

  1194.             if (err != noErr)

  1195.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

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

  1197.         } else {

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

  1199.         }

  1200. 

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

  1202. 

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

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

  1205.             return -1;

  1206.         }

  1207. 

  1208.         size = sizeof(UInt32);

  1209.         UInt32 value1 = 0;

  1210.         UInt32 value2 = 0;

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

  1212.         if (err != noErr)

  1213.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

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

  1215.         if (err != noErr)

  1216.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  1217. 

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

  1219.         port->SetAlias(alias);

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

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

  1222.         fPlaybackPortList[i] = port_index;

  1223. 

  1224.         // Monitor ports

  1225.         if (fWithMonitorPorts) {

  1226.             jack_log("Create monitor port ");

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

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

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

  1230.                 return -1;

  1231.             } else {

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

  1233.                 port->SetAlias(alias);

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

  1235.                 fMonitorPortList[i] = port_index;

  1236.             }

  1237.         }

  1238.     }

  1239. 

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

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

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

  1243.     }

  1244. 

  1245.     return 0;

  1246. }

  1247. 

  1248. int JackCoreAudioDriver::Start()

  1249. {

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

  1251.     JackAudioDriver::Start();

  1252. /*

  1253. #ifdef MAC_OS_X_VERSION_10_5

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

  1255. #else

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

  1257. #endif

  1258. */

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

  1260.     

  1261.     if (err != noErr)

  1262.         return -1;

  1263. 

  1264.     err = AudioOutputUnitStart(fAUHAL);

  1265.     if (err != noErr)

  1266.         return -1;

  1267. 

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

  1269.         jack_error("Cannot start MeasureCallback");

  1270.         printError(err);

  1271.         return -1;

  1272.     }

  1273. 

  1274.     return 0;

  1275. }

  1276. 

  1277. int JackCoreAudioDriver::Stop()

  1278. {

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

  1280.     AudioDeviceStop(fDeviceID, MeasureCallback);

  1281. /*

  1282. #ifdef MAC_OS_X_VERSION_10_5

  1283.     AudioDeviceDestroyIOProcID(fDeviceID, fMesureCallbackID);

  1284. #else

  1285.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

  1286. #endif

  1287. */

  1288.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

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

  1290. }

  1291. 

  1292. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  1293. {

  1294.     OSStatus err;

  1295.     UInt32 outSize = sizeof(UInt32);

  1296. 

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

  1298.     if (err != noErr) {

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

  1300.         printError(err);

  1301.         return -1;

  1302.     }

  1303. 

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

  1305. 

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

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

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

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

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

  1311.     }

  1312. 

  1313.     return 0;

  1314. }

  1315. 

  1316. } // end of namespace

  1317. 

  1318. 

  1319. #ifdef __cplusplus

  1320. extern "C"

  1321. {

  1322. #endif

  1323. 

  1324.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor() 

  1325.     {

  1326.         jack_driver_desc_t *desc;

  1327.         unsigned int i;

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

  1329. 

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

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

  1332.         

  1333.         desc->nparams = 15;

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

  1335. 

  1336.         i = 0;

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

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

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

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

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

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

  1343. 

  1344.         i++;

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

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

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

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

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

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

  1351. 

  1352.         i++;

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

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

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

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

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

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

  1359. 

  1360.         i++;

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

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

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

  1364.         strcpy(desc->params[i].value.str, "will take default CoreAudio input device");

  1365.         strcpy(desc->params[i].short_desc, "Provide capture ports. Optionally set CoreAudio device name");

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

  1367. 

  1368.         i++;

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

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

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

  1372.         strcpy(desc->params[i].value.str, "will take default CoreAudio output device");

  1373.         strcpy(desc->params[i].short_desc, "Provide playback ports. Optionally set CoreAudio device name");

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

  1375. 

  1376.         i++;

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

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

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

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

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

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

  1383. 

  1384.         i++;

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

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

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

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

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

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

  1391. 

  1392.         i++;

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

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

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

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

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

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

  1399. 

  1400.         i++;

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

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

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

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

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

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

  1407. 

  1408.         i++;

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

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

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

  1412.         strcpy(desc->params[i].value.str, "will take default CoreAudio device name");

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

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

  1415. 

  1416.         i++;

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

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

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

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

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

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

  1423. 

  1424.         i++;

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

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

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

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

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

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

  1431. 

  1432.         i++;

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

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

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

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

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

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

  1439.         

  1440.         i++;

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

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

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

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

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

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

  1447.         

  1448.         i++;

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

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

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

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

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

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

  1455. 

  1456.         return desc;

  1457.     }

  1458. 

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

  1460.     {

  1461.         jack_nframes_t srate = 44100;

  1462.         jack_nframes_t frames_per_interrupt = 128;

  1463.         int capture = FALSE;

  1464.         int playback = FALSE;

  1465.         int chan_in = 0;

  1466.         int chan_out = 0;

  1467.         bool monitor = false;

  1468.         const char* capture_driver_uid = "";

  1469.         const char* playback_driver_uid = "";

  1470.         const JSList *node;

  1471.         const jack_driver_param_t *param;

  1472.         jack_nframes_t systemic_input_latency = 0;

  1473.         jack_nframes_t systemic_output_latency = 0;

  1474.         int async_output_latency = 100;

  1475.         int computation_grain = -1;

  1476.     

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

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

  1479.        

  1480.             switch (param->character) {

  1481. 

  1482.                 case 'd':

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

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

  1485.                     break;

  1486. 

  1487.                 case 'D':

  1488.                     capture = TRUE;

  1489.                     playback = TRUE;

  1490.                     break;

  1491. 

  1492.                 case 'c':

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

  1494.                     break;

  1495. 

  1496.                 case 'i':

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

  1498.                     break;

  1499. 

  1500.                 case 'o':

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

  1502.                     break;

  1503. 

  1504.                 case 'C':

  1505.                     capture = TRUE;

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

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

  1508.                     }

  1509.                     break;

  1510. 

  1511.                 case 'P':

  1512.                     playback = TRUE;

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

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

  1515.                     }

  1516.                     break;

  1517. 

  1518.                 case 'm':

  1519.                     monitor = param->value.i;

  1520.                     break;

  1521. 

  1522.                 case 'r':

  1523.                     srate = param->value.ui;

  1524.                     break;

  1525. 

  1526.                 case 'p':

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

  1528.                     break;

  1529. 

  1530.                 case 'I':

  1531.                     systemic_input_latency = param->value.ui;

  1532.                     break;

  1533. 

  1534.                 case 'O':

  1535.                     systemic_output_latency = param->value.ui;

  1536.                     break;

  1537. 

  1538.                 case 'l':

  1539.                     Jack::DisplayDeviceNames();

  1540.                     break;

  1541.                     

  1542.                 case 'L':

  1543.                     async_output_latency = param->value.ui;

  1544.                     break;

  1545.                     

  1546.                 case 'G':

  1547.                     computation_grain = param->value.ui;

  1548.                     break;

  1549.             }

  1550.         }

  1551. 

  1552.         /* duplex is the default */

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

  1554.             capture = TRUE;

  1555.             playback = TRUE;

  1556.         }

  1557. 

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

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

  1560.             playback_driver_uid, systemic_input_latency, systemic_output_latency, async_output_latency, computation_grain) == 0) {

  1561.             return driver;

  1562.         } else {

  1563.             delete driver;

  1564.             return NULL;

  1565.         }

  1566.     }

  1567. 

  1568. #ifdef __cplusplus

  1569. }

  1570. #endif

  1571.