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

1615 lines
60KB
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 "JackCompilerDeps.h"

  29. 

  30. #include <iostream>

  31. #include <CoreServices/CoreServices.h>

  32. 

  33. namespace Jack

  34. {

  35. 

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

  37. {

  38.     UInt32 __4CC_number = (c);

  39.     char __4CC_string[5];

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

  41.     __4CC_string[4] = 0;

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

  43. }

  44. 

  45. static void printError(OSStatus err)

  46. {

  47.     switch (err) {

  48.         case kAudioHardwareNoError:

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

  50.             break;

  51.         case kAudioConverterErr_FormatNotSupported:

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

  53.             break;

  54.         case kAudioConverterErr_OperationNotSupported:

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

  56.             break;

  57.         case kAudioConverterErr_PropertyNotSupported:

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

  59.             break;

  60.         case kAudioConverterErr_InvalidInputSize:

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

  62.             break;

  63.         case kAudioConverterErr_InvalidOutputSize:

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

  65.             break;

  66.         case kAudioConverterErr_UnspecifiedError:

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

  68.             break;

  69.         case kAudioConverterErr_BadPropertySizeError:

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

  71.             break;

  72.         case kAudioConverterErr_RequiresPacketDescriptionsError:

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

  74.             break;

  75.         case kAudioConverterErr_InputSampleRateOutOfRange:

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

  77.             break;

  78.         case kAudioConverterErr_OutputSampleRateOutOfRange:

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

  80.             break;

  81.         case kAudioHardwareNotRunningError:

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

  83.             break;

  84.         case kAudioHardwareUnknownPropertyError:

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

  86.             break;

  87.         case kAudioHardwareIllegalOperationError:

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

  89.             break;

  90.         case kAudioHardwareBadDeviceError:

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

  92.             break;

  93.         case kAudioHardwareBadStreamError:

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

  95.             break;

  96.         case kAudioDeviceUnsupportedFormatError:

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

  98.             break;

  99.         case kAudioDevicePermissionsError:

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

  101.             break;

  102.         case kAudioHardwareBadObjectError:

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

  104.             break;

  105.         case kAudioHardwareUnsupportedOperationError:

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

  107.             break;

  108.         default:

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

  110.             break;

  111.     }

  112. }

  113. 

  114. static OSStatus DisplayDeviceNames()

  115. {

  116.     UInt32 size;

  117.     Boolean isWritable;

  118.     int i, deviceNum;

  119.     OSStatus err;

  120.     CFStringRef UIname;

  121. 

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

  123.     if (err != noErr)

  124.         return err;

  125. 

  126.     deviceNum = size / sizeof(AudioDeviceID);

  127.     AudioDeviceID devices[deviceNum];

  128. 

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

  130.     if (err != noErr)

  131.         return err;

  132. 

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

  134.         char device_name[256];

  135.         char internal_name[256];

  136. 

  137.         size = sizeof(CFStringRef);

  138.         UIname = NULL;

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

  140.         if (err == noErr) {

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

  142.         } else {

  143.             goto error;

  144.         }

  145. 

  146.         size = 256;

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

  148.         if (err != noErr)

  149.             return err;

  150. 

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

  152.     }

  153. 

  154.     return noErr;

  155. 

  156. error:

  157.     if (UIname != NULL)

  158.         CFRelease(UIname);

  159.     return err;

  160. }

  161. 

  162. static CFStringRef GetDeviceName(AudioDeviceID id)

  163. {

  164.     UInt32 size = sizeof(CFStringRef);

  165.     CFStringRef UIname;

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

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

  168. }

  169. 

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

  171.                                      AudioUnitRenderActionFlags *ioActionFlags,

  172.                                      const AudioTimeStamp *inTimeStamp,

  173.                                      UInt32 inBusNumber,

  174.                                      UInt32 inNumberFrames,

  175.                                      AudioBufferList *ioData)

  176. {

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

  178.     driver->fActionFags = ioActionFlags;

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

  180.     driver->fDriverOutputData = ioData;

  181.     driver->CycleTakeBeginTime();

  182.     return driver->Process();

  183. }

  184. 

  185. int JackCoreAudioDriver::Read()

  186. {

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

  188.     return 0;

  189. }

  190. 

  191. int JackCoreAudioDriver::Write()

  192. {

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

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

  195.             float* buffer = GetOutputBuffer(i);

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

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

  198.             // Monitor ports

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

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

  201.         } else {

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

  203.         }

  204.     }

  205.     return 0;

  206. }

  207. 

  208. // Will run only once

  209. OSStatus JackCoreAudioDriver::MeasureCallback(AudioDeviceID inDevice,

  210.         const AudioTimeStamp* inNow,

  211.         const AudioBufferList* inInputData,

  212.         const AudioTimeStamp* inInputTime,

  213.         AudioBufferList* outOutputData,

  214.         const AudioTimeStamp* inOutputTime,

  215.         void* inClientData)

  216. {

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

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

  219.     

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

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

  222.     

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

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

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

  226.     }

  227.     

  228.     // Setup threadded based log function

  229.     set_threaded_log_function();

  230.     return noErr;

  231. }

  232. 

  233. OSStatus JackCoreAudioDriver::SRNotificationCallback(AudioDeviceID inDevice,

  234.         UInt32 inChannel,

  235.         Boolean	isInput,

  236.         AudioDevicePropertyID inPropertyID,

  237.         void* inClientData)

  238. {

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

  240. 

  241.     switch (inPropertyID) {

  242. 

  243.         case kAudioDevicePropertyNominalSampleRate: {

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

  245.             driver->fState = true;

  246.             break;

  247.         }

  248.     }

  249. 

  250.     return noErr;

  251. }

  252. 

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

  254. 

  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 may not work correctly anymore...");

  274.             return kAudioHardwareUnsupportedOperationError;

  275. 		}

  276.             

  277. 		case kAudioDevicePropertyNominalSampleRate: {

  278.             jack_error("Cannot handle kAudioDevicePropertyNominalSampleRate : server may not work correctly anymore...");

  279.             return kAudioHardwareUnsupportedOperationError;

  280. 		}

  281.           

  282.         /*

  283.         case kAudioDevicePropertyNominalSampleRate: {

  284. 

  285.             UInt32 outSize = sizeof(Float64);

  286.             Float64 sampleRate;

  287.             int in_nChannels = 0;

  288.             int out_nChannels = 0;

  289.             char capture_driver_name[256];

  290.             char playback_driver_name[256];

  291.             CFStringRef ref;

  292.      

  293.             // Stop and restart

  294.             driver->Stop();

  295.             driver->RemoveListeners();

  296.             driver->CloseAUHAL();

  297. 

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

  299.             if (err != noErr) {

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

  301.                 printError(err);

  302.             }

  303.             jack_log("JackCoreAudioDriver::DeviceNotificationCallback kAudioDevicePropertyNominalSampleRate %ld", long(sampleRate));

  304. 

  305.             if (driver->SetupDevices(driver->fCaptureUID, driver->fPlaybackUID, capture_driver_name, playback_driver_name) < 0)

  306.                 return -1;

  307. 

  308.             if (driver->SetupChannels(driver->fCapturing, driver->fPlaying, driver->fInChannels, driver->fOutChannels, in_nChannels, out_nChannels, false) < 0)

  309.                 return -1;

  310. 

  311.             if (driver->SetupBufferSizeAndSampleRate(driver->fEngineControl->fBufferSize, sampleRate)  < 0)

  312.                 return -1;

  313. 

  314.             if (driver->OpenAUHAL(driver->fCapturing,

  315.                                   driver->fPlaying,

  316.                                   driver->fInChannels,

  317.                                   driver->fOutChannels,

  318.                                   in_nChannels,

  319.                                   out_nChannels,

  320.                                   driver->fEngineControl->fBufferSize,

  321.                                   sampleRate,

  322.                                   false) < 0)

  323.                 goto error;

  324. 

  325.             if (driver->AddListeners() < 0)

  326.                 goto error;

  327. 

  328.             driver->Start();

  329. 

  330.             // Send notification to be used in JackPilot or JackRouter plugin

  331.             jack_error("Device restart...");

  332.             ref = CFStringCreateWithCString(NULL, driver->fEngineControl->fServerName, kCFStringEncodingMacRoman);

  333.             CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),

  334.                     CFSTR("com.grame.jackserver.restart"),

  335.                     ref,

  336.                     NULL,

  337.                     kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);

  338.             CFRelease(ref);

  339.             return noErr;

  340. error:

  341.             driver->CloseAUHAL();

  342.             break;

  343.         }

  344.         */

  345.     }

  346.     return noErr;

  347. }

  348. 

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

  350. {

  351.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  354. 

  355.     if (inIUD == NULL) {

  356.         return kAudioHardwareUnspecifiedError;

  357.     } else {

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

  359.         CFRelease(inIUD);

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

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

  362.     }

  363. }

  364. 

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

  366. {

  367.     OSStatus res;

  368.     UInt32 theSize = sizeof(UInt32);

  369.     AudioDeviceID inDefault;

  370.     AudioDeviceID outDefault;

  371. 

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

  373.         return res;

  374. 

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

  376.         return res;

  377. 

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

  379. 

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

  381.     if (inDefault == outDefault) {

  382.         *id = inDefault;

  383.         return noErr;

  384.     } else {

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

  386.         return kAudioHardwareBadDeviceError;

  387.     }

  388. }

  389. 

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

  391. {

  392.     OSStatus res;

  393.     UInt32 theSize = sizeof(UInt32);

  394.     AudioDeviceID inDefault;

  395. 

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

  397.         return res;

  398. 

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

  400.     *id = inDefault;

  401.     return noErr;

  402. }

  403. 

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

  405. {

  406.     OSStatus res;

  407.     UInt32 theSize = sizeof(UInt32);

  408.     AudioDeviceID outDefault;

  409. 

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

  411.         return res;

  412. 

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

  414.     *id = outDefault;

  415.     return noErr;

  416. }

  417. 

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

  419. {

  420.     UInt32 size = 256;

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

  422. }

  423. 

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

  425. {

  426.     OSStatus err = noErr;

  427.     UInt32	outSize;

  428.     Boolean	outWritable;

  429.     AudioBufferList* bufferList = 0;

  430. 

  431.     channelCount = 0;

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

  433.     if (err == noErr) {

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

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

  436.         if (err == noErr) {

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

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

  439.         }

  440. 

  441.         if (bufferList)

  442.             free(bufferList);

  443.     }

  444. 

  445.     return err;

  446. }

  447. 

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

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

  450. {}

  451. 

  452. JackCoreAudioDriver::~JackCoreAudioDriver()

  453. {}

  454. 

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

  456. {

  457.     OSStatus osErr = noErr;

  458.     UInt32 outSize;

  459.     Boolean outWritable;

  460. 

  461.     //-----------------------

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

  463.     //-----------------------

  464. 

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

  466.     if (osErr != noErr) 

  467.         return osErr;

  468. 

  469.     AudioValueTranslation pluginAVT;

  470. 

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

  472.     AudioObjectID pluginID;

  473. 

  474.     pluginAVT.mInputData = &inBundleRef;

  475.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  476.     pluginAVT.mOutputData = &pluginID;

  477.     pluginAVT.mOutputDataSize = sizeof(pluginID);

  478. 

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

  480.     if (osErr != noErr) 

  481.         return osErr;

  482. 

  483.     //-----------------------

  484.     // Create a CFDictionary for our aggregate device

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

  486. 

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

  488. 

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

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

  491. 

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

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

  494. 

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

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

  497. 

  498.     //-------------------------------------------------

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

  500.     //-------------------------------------------------

  501.     

  502.     CFStringRef captureDeviceUID = GetDeviceName(captureDeviceID);

  503.     CFStringRef playbackDeviceUID = GetDeviceName(playbackDeviceID);

  504.     

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

  506.         return -1;

  507.   

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

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

  510. 

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

  512.     CFArrayAppendValue(subDevicesArray, captureDeviceUID);

  513.     CFArrayAppendValue(subDevicesArray, playbackDeviceUID);

  514. 

  515.     //-----------------------------------------------------------------------

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

  517.     //-----------------------------------------------------------------------

  518.  

  519.     AudioObjectPropertyAddress pluginAOPA;

  520.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  521.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  522.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  523.     UInt32 outDataSize;

  524. 

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

  526.     if (osErr != noErr) 

  527.         return osErr;

  528. 

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

  530.     if (osErr != noErr) 

  531.         return osErr;

  532. 

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

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

  535.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  536. 

  537.     //-------------------------

  538.     // Set the sub-device list

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

  540. 

  541.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  542.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  543.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  544.     outDataSize = sizeof(CFMutableArrayRef);

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

  546.     if (osErr != noErr)

  547.         return osErr;

  548. 

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

  550.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  551. 

  552.     //-----------------------

  553.     // Set the master device

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

  555. 

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

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

  558.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  559.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  560.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  561.     outDataSize = sizeof(CFStringRef);

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

  563.     if (osErr != noErr) 

  564.         return osErr;

  565. 

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

  567.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  568. 

  569.     //----------

  570.     // Clean up

  571.     //----------

  572. 

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

  574.     CFRelease(aggDeviceDict);

  575.     CFRelease(subDevicesArray);

  576. 

  577.     // release the device UID

  578.     CFRelease(captureDeviceUID);

  579.     CFRelease(playbackDeviceUID);

  580.     

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

  582.     return noErr;

  583. }

  584. 

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

  586. {

  587.     capture_driver_name[0] = 0;

  588.     playback_driver_name[0] = 0;

  589. 

  590.     // Duplex

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

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

  593.         

  594.         /*

  595.         AudioDeviceID captureID, playbackID;

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

  597.             return -1;

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

  599.             return -1;

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

  601.             return -1;

  602.         */

  603.         

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

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

  606.             

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

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

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

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

  611.                     return -1;

  612.                 }

  613.             }

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

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

  616.                 return -1;

  617.             }

  618.             

  619.         } else {

  620.         

  621.             // Creates agregate device

  622.             AudioDeviceID captureID, playbackID;

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

  624.                 return -1;

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

  626.                 return -1;

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

  628.                 return -1;

  629.         }

  630. 

  631.         // Capture only

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

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

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

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

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

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

  638.                 return -1;

  639.             }

  640.         }

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

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

  643.             return -1;

  644.         }

  645. 

  646.         // Playback only

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

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

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

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

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

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

  653.                 return -1;

  654.             }

  655.         }

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

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

  658.             return -1;

  659.         }

  660. 

  661.         // Use default driver in duplex mode

  662.     } else {

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

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

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

  666.             return -1;

  667.         }

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

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

  670.             return -1;

  671.         }

  672.     }

  673. 

  674.     return 0;

  675. }

  676. 

  677. /*

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

  679. */

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

  681. {

  682.     OSStatus err = noErr;

  683. 

  684.     if (capturing) {

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

  686.         if (err != noErr) {

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

  688.             printError(err);

  689.             return -1;

  690.         } else {

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

  692.         }

  693.     }

  694. 

  695.     if (playing) {

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

  697.         if (err != noErr) {

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

  699.             printError(err);

  700.             return -1;

  701.         } else {

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

  703.         }

  704.     }

  705. 

  706.     if (inchannels > in_nChannels) {

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

  708.         if (strict)

  709.             return -1;

  710.     }

  711. 

  712.     if (outchannels > out_nChannels) {

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

  714.         if (strict)

  715.             return -1;

  716.     }

  717. 

  718.     if (inchannels == 0) {

  719.         jack_log("Setup max in channels = %ld", in_nChannels);

  720.         inchannels = in_nChannels;

  721.     }

  722. 

  723.     if (outchannels == 0) {

  724.         jack_log("Setup max out channels = %ld", out_nChannels);

  725.         outchannels = out_nChannels;

  726.     }

  727. 

  728.     return 0;

  729. }

  730. 

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

  732. {

  733.     OSStatus err = noErr;

  734.     UInt32 outSize;

  735.     Float64 sampleRate;

  736. 

  737.     // Setting buffer size

  738.     outSize = sizeof(UInt32);

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

  740.     if (err != noErr) {

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

  742.         printError(err);

  743.         return -1;

  744.     }

  745. 

  746.     // Get sample rate

  747.     outSize =  sizeof(Float64);

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

  749.     if (err != noErr) {

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

  751.         printError(err);

  752.         return -1;

  753.     }

  754. 

  755.     // If needed, set new sample rate

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

  757.         sampleRate = (Float64)samplerate;

  758. 

  759.         // To get SR change notification

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

  761.         if (err != noErr) {

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

  763.             printError(err);

  764.             return -1;

  765.         }

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

  767.         if (err != noErr) {

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

  769.             printError(err);

  770.             return -1;

  771.         }

  772. 

  773.         // Waiting for SR change notification

  774.         int count = 0;

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

  776.             usleep(100000);

  777.             jack_log("Wait count = %ld", count);

  778.         }

  779. 

  780.         // Remove SR change notification

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

  782.     }

  783. 

  784.     return 0;

  785. }

  786. 

  787. int JackCoreAudioDriver::OpenAUHAL(bool capturing,

  788.                                    bool playing,

  789.                                    int inchannels,

  790.                                    int outchannels,

  791.                                    int in_nChannels,

  792.                                    int out_nChannels,

  793.                                    jack_nframes_t buffer_size,

  794.                                    jack_nframes_t samplerate,

  795.                                    bool strict)

  796. {

  797.     ComponentResult err1;

  798.     UInt32 enableIO;

  799.     AudioStreamBasicDescription srcFormat, dstFormat;

  800. 

  801.     jack_log("OpenAUHAL capturing = %ld playing = %ld inchannels = %ld outchannels = %ld in_nChannels = %ld out_nChannels = %ld ", capturing, playing, inchannels, outchannels, in_nChannels, out_nChannels);

  802. 

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

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

  805.         return -1;

  806.     }

  807.          

  808.     // AUHAL

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

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

  811. 

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

  813.     if (err1 != noErr) {

  814.         jack_error("Error calling OpenAComponent");

  815.         printError(err1);

  816.         return -1;

  817.     }

  818. 

  819.     err1 = AudioUnitInitialize(fAUHAL);

  820.     if (err1 != noErr) {

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

  822.         printError(err1);

  823.         return -1;

  824.     }

  825. 

  826.     // Start I/O

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

  828.         enableIO = 1;

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

  830.     } else {

  831.         enableIO = 0;

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

  833.     }

  834.     

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

  836.     if (err1 != noErr) {

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

  838.         printError(err1);

  839.         if (strict)

  840.             return -1;

  841.     }

  842. 

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

  844.         enableIO = 1;

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

  846.     } else {

  847.         enableIO = 0;

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

  849.     }

  850.     

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

  852.     if (err1 != noErr) {

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

  854.         printError(err1);

  855.         if (strict)

  856.             return -1;

  857.     }

  858.     

  859.     AudioDeviceID currAudioDeviceID;

  860.     UInt32 size = sizeof(AudioDeviceID);

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

  862.     if (err1 != noErr) {

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

  864.         printError(err1);

  865.         if (strict)

  866.             return -1;

  867.     } else {

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

  869.     }

  870. 

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

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

  873.     if (err1 != noErr) {

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

  875.         printError(err1);

  876.         if (strict)

  877.             return -1;

  878.     }

  879.     

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

  881.     if (err1 != noErr) {

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

  883.         printError(err1);

  884.         if (strict)

  885.             return -1;

  886.     } else {

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

  888.     }

  889. 

  890.     // Set buffer size

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

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

  893.         if (err1 != noErr) {

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

  895.             printError(err1);

  896.             if (strict)

  897.                 return -1;

  898.         }

  899.     }

  900. 

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

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

  903.         if (err1 != noErr) {

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

  905.             printError(err1);

  906.             if (strict)

  907.                 return -1;

  908.         }

  909.     }

  910. 

  911.     // Setup channel map

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

  913.         SInt32 chanArr[in_nChannels];

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

  915.             chanArr[i] = -1;

  916.         }

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

  918.             chanArr[i] = i;

  919.         }

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

  921.         if (err1 != noErr) {

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

  923.             printError(err1);

  924.         }

  925.     }

  926. 

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

  928.         SInt32 chanArr[out_nChannels];

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

  930.             chanArr[i] = -1;

  931.         }

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

  933.             chanArr[i] = i;

  934.         }

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

  936.         if (err1 != noErr) {

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

  938.             printError(err1);

  939.         }

  940.     }

  941. 

  942.     // Setup stream converters

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

  944.     srcFormat.mSampleRate = samplerate;

  945.     srcFormat.mFormatID = kAudioFormatLinearPCM;

  946.     srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  947.     srcFormat.mBytesPerPacket = sizeof(float);

  948.     srcFormat.mFramesPerPacket = 1;

  949.     srcFormat.mBytesPerFrame = sizeof(float);

  950.     srcFormat.mChannelsPerFrame = outchannels;

  951.     srcFormat.mBitsPerChannel = 32;

  952. 

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

  954.     if (err1 != noErr) {

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

  956.         printError(err1);

  957.     }

  958. 

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

  960.     dstFormat.mSampleRate = samplerate;

  961.     dstFormat.mFormatID = kAudioFormatLinearPCM;

  962.     dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  963.     dstFormat.mBytesPerPacket = sizeof(float);

  964.     dstFormat.mFramesPerPacket = 1;

  965.     dstFormat.mBytesPerFrame = sizeof(float);

  966.     dstFormat.mChannelsPerFrame = inchannels;

  967.     dstFormat.mBitsPerChannel = 32;

  968. 

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

  970.     if (err1 != noErr) {

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

  972.         printError(err1);

  973.     }

  974. 

  975.     // Setup callbacks

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

  977.         AURenderCallbackStruct output;

  978.         output.inputProc = Render;

  979.         output.inputProcRefCon = this;

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

  981.         if (err1 != noErr) {

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

  983.             printError(err1);

  984.             return -1;

  985.         }

  986.     } else {

  987.         AURenderCallbackStruct output;

  988.         output.inputProc = Render;

  989.         output.inputProcRefCon = this;

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

  991.         if (err1 != noErr) {

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

  993.             printError(err1);

  994.             return -1;

  995.         }

  996.     }

  997. 

  998.     return 0;

  999. }

  1000. 

  1001. int JackCoreAudioDriver::SetupBuffers(int inchannels)

  1002. {

  1003.     // Prepare buffers

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

  1005.     if (fJackInputData == 0) {

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

  1007.         return -1;

  1008.     }

  1009.     fJackInputData->mNumberBuffers = inchannels;

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

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

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

  1013.     }

  1014.     return 0;

  1015. }

  1016. 

  1017. void JackCoreAudioDriver::DisposeBuffers()

  1018. {

  1019.     if (fJackInputData) {

  1020.         free(fJackInputData);

  1021.         fJackInputData = 0;

  1022.     }

  1023. }

  1024. 

  1025. void JackCoreAudioDriver::CloseAUHAL()

  1026. {

  1027.     AudioUnitUninitialize(fAUHAL);

  1028.     CloseComponent(fAUHAL);

  1029. }

  1030. 

  1031. int JackCoreAudioDriver::AddListeners()

  1032. {

  1033.     OSStatus err = noErr;

  1034. 

  1035.     // Add listeners

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

  1037.     if (err != noErr) {

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

  1039.         printError(err);

  1040.         return -1;

  1041.     }

  1042. 

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

  1044.     if (err != noErr) {

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

  1046.         printError(err);

  1047.         return -1;

  1048.     }

  1049. 

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

  1051.     if (err != noErr) {

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

  1053.         printError(err);

  1054.         return -1;

  1055.     }

  1056. 

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

  1058.     if (err != noErr) {

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

  1060.         printError(err);

  1061.         return -1;

  1062.     }

  1063. 

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

  1065.     if (err != noErr) {

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

  1067.         printError(err);

  1068.         return -1;

  1069.     }

  1070. 

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

  1072.     if (err != noErr) {

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

  1074.         printError(err);

  1075.         return -1;

  1076.     }

  1077. 

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

  1079.         UInt32 outSize = sizeof(float);

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

  1081.         if (err != noErr) {

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

  1083.             printError(err);

  1084.         }

  1085.     }

  1086. 

  1087.     return 0;

  1088. }

  1089. 

  1090. void JackCoreAudioDriver::RemoveListeners()

  1091. {

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

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

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

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

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

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

  1098. }

  1099. 

  1100. int JackCoreAudioDriver::Open(jack_nframes_t buffer_size,

  1101.                               jack_nframes_t samplerate,

  1102.                               bool capturing,

  1103.                               bool playing,

  1104.                               int inchannels,

  1105.                               int outchannels,

  1106.                               bool monitor,

  1107.                               const char* capture_driver_uid,

  1108.                               const char* playback_driver_uid,

  1109.                               jack_nframes_t capture_latency,

  1110.                               jack_nframes_t playback_latency,

  1111.                               int async_output_latency,

  1112.                               int computation_grain)

  1113. {

  1114.     int in_nChannels = 0;

  1115.     int out_nChannels = 0;

  1116.     char capture_driver_name[256];

  1117.     char playback_driver_name[256];

  1118. 

  1119.     // Keep initial state

  1120.     fCapturing = capturing;

  1121.     fPlaying = playing;

  1122.     fInChannels = inchannels;

  1123.     fOutChannels = outchannels;

  1124.     fMonitor = monitor;

  1125.     strcpy(fCaptureUID, capture_driver_uid);

  1126.     strcpy(fPlaybackUID, playback_driver_uid);

  1127.     fCaptureLatency = capture_latency;

  1128.     fPlaybackLatency = playback_latency;

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

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

  1131. 

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

  1133.         return -1;

  1134. 

  1135.     // Generic JackAudioDriver Open

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

  1137.         return -1;

  1138. 

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

  1140.         return -1;

  1141. 

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

  1143.         return -1;

  1144. 

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

  1146.         goto error;

  1147. 

  1148.     if (capturing && inchannels > 0)

  1149.         if (SetupBuffers(inchannels) < 0)

  1150.             goto error;

  1151. 

  1152.     if (AddListeners() < 0)

  1153.         goto error;

  1154. 

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

  1156.     fCaptureChannels = inchannels;

  1157.     fPlaybackChannels = outchannels;

  1158.     return noErr;

  1159. 

  1160. error:

  1161.     Close();

  1162.     return -1;

  1163. }

  1164. 

  1165. int JackCoreAudioDriver::Close()

  1166. {

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

  1168.     Stop();

  1169.     JackAudioDriver::Close();

  1170.     RemoveListeners();

  1171.     DisposeBuffers();

  1172.     CloseAUHAL();

  1173.     return 0;

  1174. }

  1175. 

  1176. int JackCoreAudioDriver::Attach()

  1177. {

  1178.     OSStatus err;

  1179.     JackPort* port;

  1180.     jack_port_id_t port_index;

  1181.     UInt32 size;

  1182.     Boolean isWritable;

  1183.     char channel_name[64];

  1184.     char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  1185.     char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

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

  1187. 

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

  1189. 

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

  1191. 

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

  1193.         if (err != noErr)

  1194.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

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

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

  1197.             if (err != noErr)

  1198.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

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

  1200.         } else {

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

  1202.         }

  1203. 

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

  1205. 

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

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

  1208.             return -1;

  1209.         }

  1210. 

  1211.         size = sizeof(UInt32);

  1212.         UInt32 value1 = 0;

  1213.         UInt32 value2 = 0;

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

  1215.         if (err != noErr)

  1216.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

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

  1218.         if (err != noErr)

  1219.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  1220. 

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

  1222.         port->SetAlias(alias);

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

  1224.         fCapturePortList[i] = port_index;

  1225.     }

  1226. 

  1227.     port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  1228. 

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

  1230. 

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

  1232.         if (err != noErr)

  1233.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

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

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

  1236.             if (err != noErr)

  1237.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

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

  1239.         } else {

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

  1241.         }

  1242. 

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

  1244. 

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

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

  1247.             return -1;

  1248.         }

  1249. 

  1250.         size = sizeof(UInt32);

  1251.         UInt32 value1 = 0;

  1252.         UInt32 value2 = 0;

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

  1254.         if (err != noErr)

  1255.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

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

  1257.         if (err != noErr)

  1258.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  1259. 

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

  1261.         port->SetAlias(alias);

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

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

  1264.         fPlaybackPortList[i] = port_index;

  1265. 

  1266.         // Monitor ports

  1267.         if (fWithMonitorPorts) {

  1268.             jack_log("Create monitor port ");

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

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

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

  1272.                 return -1;

  1273.             } else {

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

  1275.                 port->SetAlias(alias);

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

  1277.                 fMonitorPortList[i] = port_index;

  1278.             }

  1279.         }

  1280.     }

  1281. 

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

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

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

  1285.     }

  1286. 

  1287.     return 0;

  1288. }

  1289. 

  1290. int JackCoreAudioDriver::Start()

  1291. {

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

  1293.     JackAudioDriver::Start();

  1294. /*

  1295. #ifdef MAC_OS_X_VERSION_10_5

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

  1297. #else

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

  1299. #endif

  1300. */

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

  1302.     

  1303.     if (err != noErr)

  1304.         return -1;

  1305. 

  1306.     err = AudioOutputUnitStart(fAUHAL);

  1307.     if (err != noErr)

  1308.         return -1;

  1309. 

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

  1311.         jack_error("Cannot start MeasureCallback");

  1312.         printError(err);

  1313.         return -1;

  1314.     }

  1315. 

  1316.     return 0;

  1317. }

  1318. 

  1319. int JackCoreAudioDriver::Stop()

  1320. {

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

  1322.     AudioDeviceStop(fDeviceID, MeasureCallback);

  1323. /*

  1324. #ifdef MAC_OS_X_VERSION_10_5

  1325.     AudioDeviceDestroyIOProcID(fDeviceID, fMesureCallbackID);

  1326. #else

  1327.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

  1328. #endif

  1329. */

  1330.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

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

  1332. }

  1333. 

  1334. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  1335. {

  1336.     OSStatus err;

  1337.     UInt32 outSize = sizeof(UInt32);

  1338. 

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

  1340.     if (err != noErr) {

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

  1342.         printError(err);

  1343.         return -1;

  1344.     }

  1345. 

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

  1347. 

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

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

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

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

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

  1353.     }

  1354. 

  1355.     return 0;

  1356. }

  1357. 

  1358. } // end of namespace

  1359. 

  1360. 

  1361. #ifdef __cplusplus

  1362. extern "C"

  1363. {

  1364. #endif

  1365. 

  1366.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor() 

  1367.     {

  1368.         jack_driver_desc_t *desc;

  1369.         unsigned int i;

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

  1371. 

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

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

  1374.         

  1375.         desc->nparams = 15;

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

  1377. 

  1378.         i = 0;

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

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

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

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

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

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

  1385. 

  1386.         i++;

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

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

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

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

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

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

  1393. 

  1394.         i++;

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

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

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

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

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

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

  1401. 

  1402.         i++;

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

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

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

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

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

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

  1409. 

  1410.         i++;

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

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

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

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

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

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

  1417. 

  1418.         i++;

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

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

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

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

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

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

  1425. 

  1426.         i++;

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

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

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

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

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

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

  1433. 

  1434.         i++;

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

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

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

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

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

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

  1441. 

  1442.         i++;

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

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

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

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

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

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

  1449. 

  1450.         i++;

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

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

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

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

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

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

  1457. 

  1458.         i++;

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

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

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

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

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

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

  1465. 

  1466.         i++;

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

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

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

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

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

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

  1473. 

  1474.         i++;

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

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

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

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

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

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

  1481.         

  1482.         i++;

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

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

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

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

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

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

  1489.         

  1490.         i++;

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

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

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

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

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

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

  1497. 

  1498.         return desc;

  1499.     }

  1500. 

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

  1502.     {

  1503.         jack_nframes_t srate = 44100;

  1504.         jack_nframes_t frames_per_interrupt = 128;

  1505.         int capture = FALSE;

  1506.         int playback = FALSE;

  1507.         int chan_in = 0;

  1508.         int chan_out = 0;

  1509.         bool monitor = false;

  1510.         const char* capture_driver_uid = "";

  1511.         const char* playback_driver_uid = "";

  1512.         const JSList *node;

  1513.         const jack_driver_param_t *param;

  1514.         jack_nframes_t systemic_input_latency = 0;

  1515.         jack_nframes_t systemic_output_latency = 0;

  1516.         int async_output_latency = 100;

  1517.         int computation_grain = -1;

  1518.     

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

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

  1521.        

  1522.             switch (param->character) {

  1523. 

  1524.                 case 'd':

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

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

  1527.                     break;

  1528. 

  1529.                 case 'D':

  1530.                     capture = TRUE;

  1531.                     playback = TRUE;

  1532.                     break;

  1533. 

  1534.                 case 'c':

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

  1536.                     break;

  1537. 

  1538.                 case 'i':

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

  1540.                     break;

  1541. 

  1542.                 case 'o':

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

  1544.                     break;

  1545. 

  1546.                 case 'C':

  1547.                     capture = TRUE;

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

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

  1550.                     }

  1551.                     break;

  1552. 

  1553.                 case 'P':

  1554.                     playback = TRUE;

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

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

  1557.                     }

  1558.                     break;

  1559. 

  1560.                 case 'm':

  1561.                     monitor = param->value.i;

  1562.                     break;

  1563. 

  1564.                 case 'r':

  1565.                     srate = param->value.ui;

  1566.                     break;

  1567. 

  1568.                 case 'p':

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

  1570.                     break;

  1571. 

  1572.                 case 'I':

  1573.                     systemic_input_latency = param->value.ui;

  1574.                     break;

  1575. 

  1576.                 case 'O':

  1577.                     systemic_output_latency = param->value.ui;

  1578.                     break;

  1579. 

  1580.                 case 'l':

  1581.                     Jack::DisplayDeviceNames();

  1582.                     break;

  1583.                     

  1584.                 case 'L':

  1585.                     async_output_latency = param->value.ui;

  1586.                     break;

  1587.                     

  1588.                 case 'G':

  1589.                     computation_grain = param->value.ui;

  1590.                     break;

  1591.             }

  1592.         }

  1593. 

  1594.         /* duplex is the default */

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

  1596.             capture = TRUE;

  1597.             playback = TRUE;

  1598.         }

  1599. 

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

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

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

  1603.             return driver;

  1604.         } else {

  1605.             delete driver;

  1606.             return NULL;

  1607.         }

  1608.     }

  1609. 

  1610. #ifdef __cplusplus

  1611. }

  1612. #endif

  1613.