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

1671 lines
62KB
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 printError(OSStatus err)

  48. {

  49.     switch (err) {

  50.         case kAudioHardwareNoError:

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

  52.             break;

  53.         case kAudioConverterErr_FormatNotSupported:

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

  55.             break;

  56.         case kAudioConverterErr_OperationNotSupported:

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

  58.             break;

  59.         case kAudioConverterErr_PropertyNotSupported:

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

  61.             break;

  62.         case kAudioConverterErr_InvalidInputSize:

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

  64.             break;

  65.         case kAudioConverterErr_InvalidOutputSize:

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

  67.             break;

  68.         case kAudioConverterErr_UnspecifiedError:

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

  70.             break;

  71.         case kAudioConverterErr_BadPropertySizeError:

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

  73.             break;

  74.         case kAudioConverterErr_RequiresPacketDescriptionsError:

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

  76.             break;

  77.         case kAudioConverterErr_InputSampleRateOutOfRange:

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

  79.             break;

  80.         case kAudioConverterErr_OutputSampleRateOutOfRange:

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

  82.             break;

  83.         case kAudioHardwareNotRunningError:

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

  85.             break;

  86.         case kAudioHardwareUnknownPropertyError:

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

  88.             break;

  89.         case kAudioHardwareIllegalOperationError:

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

  91.             break;

  92.         case kAudioHardwareBadDeviceError:

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

  94.             break;

  95.         case kAudioHardwareBadStreamError:

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

  97.             break;

  98.         case kAudioDeviceUnsupportedFormatError:

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

  100.             break;

  101.         case kAudioDevicePermissionsError:

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

  103.             break;

  104.         case kAudioHardwareBadObjectError:

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

  106.             break;

  107.         case kAudioHardwareUnsupportedOperationError:

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

  109.             break;

  110.         default:

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

  112.             break;

  113.     }

  114. }

  115. 

  116. static OSStatus DisplayDeviceNames()

  117. {

  118.     UInt32 size;

  119.     Boolean isWritable;

  120.     int i, deviceNum;

  121.     OSStatus err;

  122.     CFStringRef UIname;

  123. 

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

  125.     if (err != noErr)

  126.         return err;

  127. 

  128.     deviceNum = size / sizeof(AudioDeviceID);

  129.     AudioDeviceID devices[deviceNum];

  130. 

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

  132.     if (err != noErr)

  133.         return err;

  134. 

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

  136.         char device_name[256];

  137.         char internal_name[256];

  138. 

  139.         size = sizeof(CFStringRef);

  140.         UIname = NULL;

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

  142.         if (err == noErr) {

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

  144.         } else {

  145.             goto error;

  146.         }

  147. 

  148.         size = 256;

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

  150.         if (err != noErr)

  151.             return err;

  152. 

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

  154.     }

  155. 

  156.     return noErr;

  157. 

  158. error:

  159.     if (UIname != NULL)

  160.         CFRelease(UIname);

  161.     return err;

  162. }

  163. 

  164. static CFStringRef GetDeviceName(AudioDeviceID id)

  165. {

  166.     UInt32 size = sizeof(CFStringRef);

  167.     CFStringRef UIname;

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

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

  170. }

  171. 

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

  173.                                      AudioUnitRenderActionFlags *ioActionFlags,

  174.                                      const AudioTimeStamp *inTimeStamp,

  175.                                      UInt32 inBusNumber,

  176.                                      UInt32 inNumberFrames,

  177.                                      AudioBufferList *ioData)

  178. {

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

  180.     driver->fActionFags = ioActionFlags;

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

  182.     driver->fDriverOutputData = ioData;

  183.     driver->CycleTakeBeginTime();

  184.     return driver->Process();

  185. }

  186. 

  187. int JackCoreAudioDriver::Read()

  188. {

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

  190.     return 0;

  191. }

  192. 

  193. int JackCoreAudioDriver::Write()

  194. {

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

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

  197.             float* buffer = GetOutputBuffer(i);

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

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

  200.             // Monitor ports

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

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

  203.         } else {

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

  205.         }

  206.     }

  207.     return 0;

  208. }

  209. 

  210. // Will run only once

  211. OSStatus JackCoreAudioDriver::MeasureCallback(AudioDeviceID inDevice,

  212.         const AudioTimeStamp* inNow,

  213.         const AudioBufferList* inInputData,

  214.         const AudioTimeStamp* inInputTime,

  215.         AudioBufferList* outOutputData,

  216.         const AudioTimeStamp* inOutputTime,

  217.         void* inClientData)

  218. {

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

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

  221.     

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

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

  224.     

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

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

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

  228.     }

  229.     

  230.     // Setup threadded based log function

  231.     set_threaded_log_function();

  232.     return noErr;

  233. }

  234. 

  235. OSStatus JackCoreAudioDriver::SRNotificationCallback(AudioDeviceID inDevice,

  236.         UInt32 inChannel,

  237.         Boolean	isInput,

  238.         AudioDevicePropertyID inPropertyID,

  239.         void* inClientData)

  240. {

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

  242. 

  243.     switch (inPropertyID) {

  244. 

  245.         case kAudioDevicePropertyNominalSampleRate: {

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

  247.             driver->fState = true;

  248.             break;

  249.         }

  250.     }

  251. 

  252.     return noErr;

  253. }

  254. 

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

  256. OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,

  257.         UInt32 inChannel,

  258.         Boolean	isInput,

  259.         AudioDevicePropertyID inPropertyID,

  260.         void* inClientData)

  261. {

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

  263.          

  264.     switch (inPropertyID) {

  265.         

  266.         case kAudioDeviceProcessorOverload: {

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

  268.             jack_time_t cur_time = GetMicroSeconds();

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

  270.             break;

  271.         }

  272.         

  273.         case kAudioDevicePropertyStreamConfiguration: {

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

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

  276.             driver->CloseAUHAL();

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

  278.             return kAudioHardwareUnsupportedOperationError;

  279.         }

  280.         

  281.         case kAudioDevicePropertyNominalSampleRate: {

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

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

  284.             driver->CloseAUHAL();

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

  286.             return kAudioHardwareUnsupportedOperationError;

  287. 		}

  288.             

  289.     }

  290.     return noErr;

  291. }

  292. 

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

  294. {

  295.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  298. 

  299.     if (inIUD == NULL) {

  300.         return kAudioHardwareUnspecifiedError;

  301.     } else {

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

  303.         CFRelease(inIUD);

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

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

  306.     }

  307. }

  308. 

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

  310. {

  311.     OSStatus res;

  312.     UInt32 theSize = sizeof(UInt32);

  313.     AudioDeviceID inDefault;

  314.     AudioDeviceID outDefault;

  315. 

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

  317.         return res;

  318. 

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

  320.         return res;

  321. 

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

  323. 

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

  325.     if (inDefault == outDefault) {

  326.         *id = inDefault;

  327.         return noErr;

  328.     } else {

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

  330.         return kAudioHardwareBadDeviceError;

  331.     }

  332. }

  333. 

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

  335. {

  336.     OSStatus res;

  337.     UInt32 theSize = sizeof(UInt32);

  338.     AudioDeviceID inDefault;

  339. 

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

  341.         return res;

  342. 

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

  344.     *id = inDefault;

  345.     return noErr;

  346. }

  347. 

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

  349. {

  350.     OSStatus res;

  351.     UInt32 theSize = sizeof(UInt32);

  352.     AudioDeviceID outDefault;

  353. 

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

  355.         return res;

  356. 

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

  358.     *id = outDefault;

  359.     return noErr;

  360. }

  361. 

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

  363. {

  364.     UInt32 size = 256;

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

  366. }

  367. 

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

  369. {

  370.     OSStatus err = noErr;

  371.     UInt32	outSize;

  372.     Boolean	outWritable;

  373.     AudioBufferList* bufferList = 0;

  374. 

  375.     channelCount = 0;

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

  377.     if (err == noErr) {

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

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

  380.         if (err == noErr) {

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

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

  383.         }

  384. 

  385.         if (bufferList)

  386.             free(bufferList);

  387.     }

  388. 

  389.     return err;

  390. }

  391. 

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

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

  394.         fJackInputData(NULL), 

  395.         fDriverOutputData(NULL), 

  396.         fPluginID(0), 

  397.         fState(false), 

  398.         fHogged(false),

  399.         fIOUsage(1.f),

  400.         fComputationGrain(-1.f)

  401. {}

  402. 

  403. JackCoreAudioDriver::~JackCoreAudioDriver()

  404. {}

  405. 

  406. OSStatus JackCoreAudioDriver::DestroyAggregateDevice() 

  407. {

  408.     OSStatus osErr = noErr;

  409.     AudioObjectPropertyAddress pluginAOPA;

  410.     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;

  411.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  412.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  413.     UInt32 outDataSize;

  414.   

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

  416.     if (osErr != noErr) {

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

  418.         printError(osErr);

  419.         return osErr;

  420.     }

  421.         

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

  423.     if (osErr != noErr) {

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

  425.         printError(osErr);

  426.         return osErr;

  427.     }

  428.     

  429.     return noErr;

  430. }

  431. 

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

  433. {

  434.     OSStatus osErr = noErr;

  435.     UInt32 outSize;

  436.     Boolean outWritable;

  437. 

  438.     //---------------------------------------------------------------------------

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

  440.     //---------------------------------------------------------------------------

  441.     

  442.     char capture_name[256];

  443.     char playback_name[256];

  444.     GetDeviceNameFromID(captureDeviceID, capture_name);

  445.     GetDeviceNameFromID(playbackDeviceID, playback_name);

  446.     jack_info("Separated input = '%s' and output = '%s' devices, create a private aggregate device to handle them...", capture_name, playback_name);

  447.  

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

  449.     if (osErr != noErr) 

  450.         return osErr;

  451. 

  452.     AudioValueTranslation pluginAVT;

  453. 

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

  455.    

  456.     pluginAVT.mInputData = &inBundleRef;

  457.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  458.     pluginAVT.mOutputData = &fPluginID;

  459.     pluginAVT.mOutputDataSize = sizeof(fPluginID);

  460. 

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

  462.     if (osErr != noErr) 

  463.         return osErr;

  464. 

  465.     //-------------------------------------------------

  466.     // Create a CFDictionary for our aggregate device

  467.     //-------------------------------------------------

  468. 

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

  470. 

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

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

  473.     

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

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

  476. 

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

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

  479.     

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

  481.     int value = 1;

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

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

  484.   

  485.     //-------------------------------------------------

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

  487.     //-------------------------------------------------

  488.     

  489.     CFStringRef captureDeviceUID = GetDeviceName(captureDeviceID);

  490.     CFStringRef playbackDeviceUID = GetDeviceName(playbackDeviceID);

  491.     

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

  493.         return -1;

  494.   

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

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

  497. 

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

  499.     CFArrayAppendValue(subDevicesArray, captureDeviceUID);

  500.     CFArrayAppendValue(subDevicesArray, playbackDeviceUID);

  501. 

  502.     //-----------------------------------------------------------------------

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

  504.     //-----------------------------------------------------------------------

  505.  

  506.     AudioObjectPropertyAddress pluginAOPA;

  507.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  508.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  509.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  510.     UInt32 outDataSize;

  511. 

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

  513.     if (osErr != noErr) 

  514.         return osErr;

  515. 

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

  517.     if (osErr != noErr) 

  518.         return osErr;

  519. 

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

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

  522.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  523. 

  524.     //-------------------------

  525.     // Set the sub-device list

  526.     //-------------------------

  527. 

  528.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  529.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  530.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  531.     outDataSize = sizeof(CFMutableArrayRef);

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

  533.     if (osErr != noErr)

  534.         return osErr;

  535. 

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

  537.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  538. 

  539.     //-----------------------

  540.     // Set the master device

  541.     //-----------------------

  542. 

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

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

  545.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  546.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  547.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  548.     outDataSize = sizeof(CFStringRef);

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

  550.     if (osErr != noErr) 

  551.         return osErr;

  552. 

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

  554.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  555. 

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

  557.     // Clean up

  558.     //----------

  559.     

  560.     CFRelease(AggregateDeviceNumberRef);

  561. 

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

  563.     CFRelease(aggDeviceDict);

  564.     CFRelease(subDevicesArray);

  565. 

  566.     // release the device UID

  567.     CFRelease(captureDeviceUID);

  568.     CFRelease(playbackDeviceUID);

  569.     

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

  571.     return noErr;

  572. }

  573. 

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

  575. {

  576.     capture_driver_name[0] = 0;

  577.     playback_driver_name[0] = 0;

  578. 

  579.     // Duplex

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

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

  582.           

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

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

  585.             

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

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

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

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

  590.                     return -1;

  591.                 }

  592.             }

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

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

  595.                 return -1;

  596.             }

  597.             

  598.         } else {

  599.         

  600.             // Creates aggregate device

  601.             AudioDeviceID captureID, playbackID;

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

  603.                 return -1;

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

  605.                 return -1;

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

  607.                 return -1;

  608.         }

  609. 

  610.     // Capture only

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

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

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

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

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

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

  617.                 return -1;

  618.             }

  619.         }

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

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

  622.             return -1;

  623.         }

  624. 

  625.     // Playback only

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

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

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

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

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

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

  632.                 return -1;

  633.             }

  634.         }

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

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

  637.             return -1;

  638.         }

  639. 

  640.     // Use default driver in duplex mode

  641.     } else {

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

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

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

  645.             return -1;

  646.         }

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

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

  649.             return -1;

  650.         }

  651.     }

  652.     

  653.     if (fHogged) {

  654.         if (TakeHog()) {

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

  656.         } else {

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

  658.         }

  659.     }

  660. 

  661.     return 0;

  662. }

  663. 

  664. /*

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

  666. */

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

  668. {

  669.     OSStatus err = noErr;

  670. 

  671.     if (capturing) {

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

  673.         if (err != noErr) {

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

  675.             printError(err);

  676.             return -1;

  677.         } else {

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

  679.         }

  680.     }

  681. 

  682.     if (playing) {

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

  684.         if (err != noErr) {

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

  686.             printError(err);

  687.             return -1;

  688.         } else {

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

  690.         }

  691.     }

  692. 

  693.     if (inchannels > in_nChannels) {

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

  695.         if (strict)

  696.             return -1;

  697.     }

  698. 

  699.     if (outchannels > out_nChannels) {

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

  701.         if (strict)

  702.             return -1;

  703.     }

  704. 

  705.     if (inchannels == 0) {

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

  707.         inchannels = in_nChannels;

  708.     }

  709. 

  710.     if (outchannels == 0) {

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

  712.         outchannels = out_nChannels;

  713.     }

  714. 

  715.     return 0;

  716. }

  717. 

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

  719. {

  720.     OSStatus err = noErr;

  721.     UInt32 outSize;

  722.     Float64 sampleRate;

  723. 

  724.     // Setting buffer size

  725.     outSize = sizeof(UInt32);

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

  727.     if (err != noErr) {

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

  729.         printError(err);

  730.         return -1;

  731.     }

  732. 

  733.     // Get sample rate

  734.     outSize =  sizeof(Float64);

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

  736.     if (err != noErr) {

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

  738.         printError(err);

  739.         return -1;

  740.     }

  741. 

  742.     // If needed, set new sample rate

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

  744.         sampleRate = (Float64)samplerate;

  745. 

  746.         // To get SR change notification

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

  748.         if (err != noErr) {

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

  750.             printError(err);

  751.             return -1;

  752.         }

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

  754.         if (err != noErr) {

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

  756.             printError(err);

  757.             return -1;

  758.         }

  759. 

  760.         // Waiting for SR change notification

  761.         int count = 0;

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

  763.             usleep(100000);

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

  765.         }

  766. 

  767.         // Remove SR change notification

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

  769.     }

  770. 

  771.     return 0;

  772. }

  773. 

  774. int JackCoreAudioDriver::OpenAUHAL(bool capturing,

  775.                                    bool playing,

  776.                                    int inchannels,

  777.                                    int outchannels,

  778.                                    int in_nChannels,

  779.                                    int out_nChannels,

  780.                                    jack_nframes_t buffer_size,

  781.                                    jack_nframes_t samplerate,

  782.                                    bool strict)

  783. {

  784.     ComponentResult err1;

  785.     UInt32 enableIO;

  786.     AudioStreamBasicDescription srcFormat, dstFormat;

  787. 

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

  789. 

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

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

  792.         return -1;

  793.     }

  794.          

  795.     // AUHAL

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

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

  798. 

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

  800.     if (err1 != noErr) {

  801.         jack_error("Error calling OpenAComponent");

  802.         printError(err1);

  803.         return -1;

  804.     }

  805. 

  806.     err1 = AudioUnitInitialize(fAUHAL);

  807.     if (err1 != noErr) {

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

  809.         printError(err1);

  810.         return -1;

  811.     }

  812. 

  813.     // Start I/O

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

  815.         enableIO = 1;

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

  817.     } else {

  818.         enableIO = 0;

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

  820.     }

  821.     

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

  823.     if (err1 != noErr) {

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

  825.         printError(err1);

  826.         if (strict)

  827.             return -1;

  828.     }

  829. 

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

  831.         enableIO = 1;

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

  833.     } else {

  834.         enableIO = 0;

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

  836.     }

  837.     

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

  839.     if (err1 != noErr) {

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

  841.         printError(err1);

  842.         if (strict)

  843.             return -1;

  844.     }

  845.     

  846.     AudioDeviceID currAudioDeviceID;

  847.     UInt32 size = sizeof(AudioDeviceID);

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

  849.     if (err1 != noErr) {

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

  851.         printError(err1);

  852.         if (strict)

  853.             return -1;

  854.     } else {

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

  856.     }

  857. 

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

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

  860.     if (err1 != noErr) {

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

  862.         printError(err1);

  863.         if (strict)

  864.             return -1;

  865.     }

  866.   

  867.     // Set buffer size

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

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

  870.         if (err1 != noErr) {

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

  872.             printError(err1);

  873.             if (strict)

  874.                 return -1;

  875.         }

  876.     }

  877. 

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

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

  880.         if (err1 != noErr) {

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

  882.             printError(err1);

  883.             if (strict)

  884.                 return -1;

  885.         }

  886.     }

  887. 

  888.     // Setup channel map

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

  890.         SInt32 chanArr[in_nChannels];

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

  892.             chanArr[i] = -1;

  893.         }

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

  895.             chanArr[i] = i;

  896.         }

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

  898.         if (err1 != noErr) {

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

  900.             printError(err1);

  901.         }

  902.     }

  903. 

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

  905.         SInt32 chanArr[out_nChannels];

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

  907.             chanArr[i] = -1;

  908.         }

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

  910.             chanArr[i] = i;

  911.         }

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

  913.         if (err1 != noErr) {

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

  915.             printError(err1);

  916.         }

  917.     }

  918. 

  919.     // Setup stream converters

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

  921.     srcFormat.mSampleRate = samplerate;

  922.     srcFormat.mFormatID = kAudioFormatLinearPCM;

  923.     srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  924.     srcFormat.mBytesPerPacket = sizeof(float);

  925.     srcFormat.mFramesPerPacket = 1;

  926.     srcFormat.mBytesPerFrame = sizeof(float);

  927.     srcFormat.mChannelsPerFrame = outchannels;

  928.     srcFormat.mBitsPerChannel = 32;

  929. 

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

  931.     if (err1 != noErr) {

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

  933.         printError(err1);

  934.     }

  935. 

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

  937.     dstFormat.mSampleRate = samplerate;

  938.     dstFormat.mFormatID = kAudioFormatLinearPCM;

  939.     dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  940.     dstFormat.mBytesPerPacket = sizeof(float);

  941.     dstFormat.mFramesPerPacket = 1;

  942.     dstFormat.mBytesPerFrame = sizeof(float);

  943.     dstFormat.mChannelsPerFrame = inchannels;

  944.     dstFormat.mBitsPerChannel = 32;

  945. 

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

  947.     if (err1 != noErr) {

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

  949.         printError(err1);

  950.     }

  951. 

  952.     // Setup callbacks

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

  954.         AURenderCallbackStruct output;

  955.         output.inputProc = Render;

  956.         output.inputProcRefCon = this;

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

  958.         if (err1 != noErr) {

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

  960.             printError(err1);

  961.             return -1;

  962.         }

  963.     } else {

  964.         AURenderCallbackStruct output;

  965.         output.inputProc = Render;

  966.         output.inputProcRefCon = this;

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

  968.         if (err1 != noErr) {

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

  970.             printError(err1);

  971.             return -1;

  972.         }

  973.     }

  974. 

  975.     return 0;

  976. }

  977. 

  978. int JackCoreAudioDriver::SetupBuffers(int inchannels)

  979. {

  980.     // Prepare buffers

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

  982.     if (fJackInputData == 0) {

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

  984.         return -1;

  985.     }

  986.     fJackInputData->mNumberBuffers = inchannels;

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

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

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

  990.     }

  991.     return 0;

  992. }

  993. 

  994. void JackCoreAudioDriver::DisposeBuffers()

  995. {

  996.     if (fJackInputData) {

  997.         free(fJackInputData);

  998.         fJackInputData = 0;

  999.     }

  1000. }

  1001. 

  1002. void JackCoreAudioDriver::CloseAUHAL()

  1003. {

  1004.     AudioUnitUninitialize(fAUHAL);

  1005.     CloseComponent(fAUHAL);

  1006. }

  1007. 

  1008. int JackCoreAudioDriver::AddListeners()

  1009. {

  1010.     OSStatus err = noErr;

  1011. 

  1012.     // Add listeners

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

  1014.     if (err != noErr) {

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

  1016.         printError(err);

  1017.         return -1;

  1018.     }

  1019. 

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

  1021.     if (err != noErr) {

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

  1023.         printError(err);

  1024.         return -1;

  1025.     }

  1026. 

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

  1028.     if (err != noErr) {

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

  1030.         printError(err);

  1031.         return -1;

  1032.     }

  1033. 

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

  1035.     if (err != noErr) {

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

  1037.         printError(err);

  1038.         return -1;

  1039.     }

  1040. 

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

  1042.     if (err != noErr) {

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

  1044.         printError(err);

  1045.         return -1;

  1046.     }

  1047. 

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

  1049.     if (err != noErr) {

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

  1051.         printError(err);

  1052.         return -1;

  1053.     }

  1054. 

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

  1056.         UInt32 outSize = sizeof(float);

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

  1058.         if (err != noErr) {

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

  1060.             printError(err);

  1061.         }

  1062.     }

  1063. 

  1064.     return 0;

  1065. }

  1066. 

  1067. void JackCoreAudioDriver::RemoveListeners()

  1068. {

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

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

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

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

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

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

  1075. }

  1076. 

  1077. int JackCoreAudioDriver::Open(jack_nframes_t buffer_size,

  1078.                               jack_nframes_t samplerate,

  1079.                               bool capturing,

  1080.                               bool playing,

  1081.                               int inchannels,

  1082.                               int outchannels,

  1083.                               bool monitor,

  1084.                               const char* capture_driver_uid,

  1085.                               const char* playback_driver_uid,

  1086.                               jack_nframes_t capture_latency,

  1087.                               jack_nframes_t playback_latency,

  1088.                               int async_output_latency,

  1089.                               int computation_grain,

  1090.                               bool hogged)

  1091. {

  1092.     int in_nChannels = 0;

  1093.     int out_nChannels = 0;

  1094.     char capture_driver_name[256];

  1095.     char playback_driver_name[256];

  1096. 

  1097.     // Keep initial state

  1098.     fCapturing = capturing;

  1099.     fPlaying = playing;

  1100.     fInChannels = inchannels;

  1101.     fOutChannels = outchannels;

  1102.     fMonitor = monitor;

  1103.     strcpy(fCaptureUID, capture_driver_uid);

  1104.     strcpy(fPlaybackUID, playback_driver_uid);

  1105.     fCaptureLatency = capture_latency;

  1106.     fPlaybackLatency = playback_latency;

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

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

  1109.     fHogged = hogged;

  1110.     

  1111.     SInt32 major;

  1112.     SInt32 minor;

  1113.     Gestalt(gestaltSystemVersionMajor, &major);

  1114.     Gestalt(gestaltSystemVersionMinor, &minor);

  1115.     

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

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

  1118.         CFRunLoopRef theRunLoop = NULL;

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

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

  1121.         if (theError != noErr) {

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

  1123.         }

  1124.     }

  1125. 

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

  1127.         return -1;

  1128. 

  1129.     // Generic JackAudioDriver Open

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

  1131.         return -1;

  1132. 

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

  1134.         return -1;

  1135. 

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

  1137.         return -1;

  1138.  

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

  1140.         goto error;

  1141. 

  1142.     if (capturing && inchannels > 0)

  1143.         if (SetupBuffers(inchannels) < 0)

  1144.             goto error;

  1145. 

  1146.     if (AddListeners() < 0)

  1147.         goto error;

  1148. 

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

  1150.     fCaptureChannels = inchannels;

  1151.     fPlaybackChannels = outchannels;

  1152.     return noErr;

  1153. 

  1154. error:

  1155.     Close();

  1156.     return -1;

  1157. }

  1158. 

  1159. int JackCoreAudioDriver::Close()

  1160. {

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

  1162.     Stop();

  1163.     JackAudioDriver::Close();

  1164.     RemoveListeners();

  1165.     DisposeBuffers();

  1166.     CloseAUHAL();

  1167.     if (fPluginID > 0)

  1168.         DestroyAggregateDevice();

  1169.     return 0;

  1170. }

  1171. 

  1172. int JackCoreAudioDriver::Attach()

  1173. {

  1174.     OSStatus err;

  1175.     JackPort* port;

  1176.     jack_port_id_t port_index;

  1177.     UInt32 size;

  1178.     Boolean isWritable;

  1179.     char channel_name[64];

  1180.     char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  1181.     char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

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

  1183. 

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

  1185. 

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

  1187. 

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

  1189.         if (err != noErr)

  1190.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

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

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

  1193.             if (err != noErr)

  1194.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

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

  1196.         } else {

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

  1198.         }

  1199. 

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

  1201. 

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

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

  1204.             return -1;

  1205.         }

  1206. 

  1207.         size = sizeof(UInt32);

  1208.         UInt32 value1 = 0;

  1209.         UInt32 value2 = 0;

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

  1211.         if (err != noErr)

  1212.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

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

  1214.         if (err != noErr)

  1215.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  1216. 

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

  1218.         port->SetAlias(alias);

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

  1220.         fCapturePortList[i] = port_index;

  1221.     }

  1222. 

  1223.     port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  1224. 

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

  1226. 

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

  1228.         if (err != noErr)

  1229.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

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

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

  1232.             if (err != noErr)

  1233.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

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

  1235.         } else {

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

  1237.         }

  1238. 

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

  1240. 

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

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

  1243.             return -1;

  1244.         }

  1245. 

  1246.         size = sizeof(UInt32);

  1247.         UInt32 value1 = 0;

  1248.         UInt32 value2 = 0;

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

  1250.         if (err != noErr)

  1251.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

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

  1253.         if (err != noErr)

  1254.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  1255. 

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

  1257.         port->SetAlias(alias);

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

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

  1260.         fPlaybackPortList[i] = port_index;

  1261. 

  1262.         // Monitor ports

  1263.         if (fWithMonitorPorts) {

  1264.             jack_log("Create monitor port ");

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

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

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

  1268.                 return -1;

  1269.             } else {

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

  1271.                 port->SetAlias(alias);

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

  1273.                 fMonitorPortList[i] = port_index;

  1274.             }

  1275.         }

  1276.     }

  1277. 

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

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

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

  1281.     }

  1282. 

  1283.     return 0;

  1284. }

  1285. 

  1286. int JackCoreAudioDriver::Start()

  1287. {

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

  1289.     JackAudioDriver::Start();

  1290. /*

  1291. #ifdef MAC_OS_X_VERSION_10_5

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

  1293. #else

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

  1295. #endif

  1296. */

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

  1298.     

  1299.     if (err != noErr)

  1300.         return -1;

  1301. 

  1302.     err = AudioOutputUnitStart(fAUHAL);

  1303.     if (err != noErr)

  1304.         return -1;

  1305. 

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

  1307.         jack_error("Cannot start MeasureCallback");

  1308.         printError(err);

  1309.         return -1;

  1310.     }

  1311. 

  1312.     return 0;

  1313. }

  1314. 

  1315. int JackCoreAudioDriver::Stop()

  1316. {

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

  1318.     AudioDeviceStop(fDeviceID, MeasureCallback);

  1319. /*

  1320. #ifdef MAC_OS_X_VERSION_10_5

  1321.     AudioDeviceDestroyIOProcID(fDeviceID, fMesureCallbackID);

  1322. #else

  1323.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

  1324. #endif

  1325. */

  1326.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

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

  1328. }

  1329. 

  1330. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  1331. {

  1332.     OSStatus err;

  1333.     UInt32 outSize = sizeof(UInt32);

  1334. 

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

  1336.     if (err != noErr) {

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

  1338.         printError(err);

  1339.         return -1;

  1340.     }

  1341. 

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

  1343. 

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

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

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

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

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

  1349.     }

  1350. 

  1351.     return 0;

  1352. }

  1353. 

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

  1355. {

  1356.     pid_t hog_pid;

  1357.     OSStatus err;

  1358. 

  1359.     UInt32 propSize = sizeof(hog_pid);

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

  1361.     if (err) {

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

  1363.         printError(err);

  1364.     }

  1365. 

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

  1367.         hog_pid = getpid();

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

  1369.         if (err != noErr) {

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

  1371.             return false;

  1372.         }

  1373.     }

  1374.     

  1375.     return true;

  1376. }

  1377.     

  1378. bool JackCoreAudioDriver::TakeHog()

  1379. {

  1380.     OSStatus err = noErr;

  1381.     AudioObjectID sub_device[32];

  1382.     UInt32 outSize = sizeof(sub_device);

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

  1384.     

  1385.     if (err != noErr) {

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

  1387.         return TakeHogAux(fDeviceID, true);

  1388.     } else {

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

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

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

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

  1393.                 return false;

  1394.             }

  1395.         }

  1396.         return true;

  1397.     }

  1398. }

  1399.     

  1400. 

  1401. } // end of namespace

  1402. 

  1403. 

  1404. #ifdef __cplusplus

  1405. extern "C"

  1406. {

  1407. #endif

  1408. 

  1409.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor() 

  1410.     {

  1411.         jack_driver_desc_t *desc;

  1412.         unsigned int i;

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

  1414. 

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

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

  1417.         

  1418.         desc->nparams = 16;

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

  1420. 

  1421.         i = 0;

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

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

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

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

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

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

  1428. 

  1429.         i++;

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

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

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

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

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

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

  1436. 

  1437.         i++;

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

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

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

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

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

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

  1444. 

  1445.         i++;

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

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

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

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

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

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

  1452. 

  1453.         i++;

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

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

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

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

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

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

  1460. 

  1461.         i++;

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

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

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

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

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

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

  1468. 

  1469.         i++;

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

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

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

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

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

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

  1476. 

  1477.         i++;

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

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

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

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

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

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

  1484. 

  1485.         i++;

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

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

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

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

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

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

  1492. 

  1493.         i++;

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

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

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

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

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

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

  1500. 

  1501.         i++;

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

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

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

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

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

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

  1508. 

  1509.         i++;

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

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

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

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

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

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

  1516. 

  1517.         i++;

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

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

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

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

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

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

  1524.         

  1525.         i++;

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

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

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

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

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

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

  1532.         

  1533.         i++;

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

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

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

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

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

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

  1540.         

  1541.         i++;

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

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

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

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

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

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

  1548. 

  1549.         return desc;

  1550.     }

  1551. 

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

  1553.     {

  1554.         jack_nframes_t srate = 44100;

  1555.         jack_nframes_t frames_per_interrupt = 128;

  1556.         int capture = FALSE;

  1557.         int playback = FALSE;

  1558.         int chan_in = 0;

  1559.         int chan_out = 0;

  1560.         bool monitor = false;

  1561.         const char* capture_driver_uid = "";

  1562.         const char* playback_driver_uid = "";

  1563.         const JSList *node;

  1564.         const jack_driver_param_t *param;

  1565.         jack_nframes_t systemic_input_latency = 0;

  1566.         jack_nframes_t systemic_output_latency = 0;

  1567.         int async_output_latency = 100;

  1568.         int computation_grain = -1;

  1569.         bool hogged = false;

  1570.     

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

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

  1573.        

  1574.             switch (param->character) {

  1575. 

  1576.                 case 'd':

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

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

  1579.                     break;

  1580. 

  1581.                 case 'D':

  1582.                     capture = TRUE;

  1583.                     playback = TRUE;

  1584.                     break;

  1585. 

  1586.                 case 'c':

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

  1588.                     break;

  1589. 

  1590.                 case 'i':

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

  1592.                     break;

  1593. 

  1594.                 case 'o':

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

  1596.                     break;

  1597. 

  1598.                 case 'C':

  1599.                     capture = TRUE;

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

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

  1602.                     }

  1603.                     break;

  1604. 

  1605.                 case 'P':

  1606.                     playback = TRUE;

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

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

  1609.                     }

  1610.                     break;

  1611. 

  1612.                 case 'm':

  1613.                     monitor = param->value.i;

  1614.                     break;

  1615. 

  1616.                 case 'r':

  1617.                     srate = param->value.ui;

  1618.                     break;

  1619. 

  1620.                 case 'p':

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

  1622.                     break;

  1623. 

  1624.                 case 'I':

  1625.                     systemic_input_latency = param->value.ui;

  1626.                     break;

  1627. 

  1628.                 case 'O':

  1629.                     systemic_output_latency = param->value.ui;

  1630.                     break;

  1631. 

  1632.                 case 'l':

  1633.                     Jack::DisplayDeviceNames();

  1634.                     break;

  1635.                     

  1636.                 case 'H':

  1637.                     hogged = true;

  1638.                     break;

  1639.                     

  1640.                 case 'L':

  1641.                     async_output_latency = param->value.ui;

  1642.                     break;

  1643.                     

  1644.                 case 'G':

  1645.                     computation_grain = param->value.ui;

  1646.                     break;

  1647.             }

  1648.         }

  1649. 

  1650.         /* duplex is the default */

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

  1652.             capture = TRUE;

  1653.             playback = TRUE;

  1654.         }

  1655. 

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

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

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

  1659.             return driver;

  1660.         } else {

  1661.             delete driver;

  1662.             return NULL;

  1663.         }

  1664.     }

  1665. 

  1666. #ifdef __cplusplus

  1667. }

  1668. #endif

  1669.