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

1769 lines
66KB
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.     // Signal waiting start function...

  231.     driver->fState = true;

  232.     

  233.     // Setup threadded based log function

  234.     set_threaded_log_function();

  235.     return noErr;

  236. }

  237. 

  238. OSStatus JackCoreAudioDriver::SRNotificationCallback(AudioDeviceID inDevice,

  239.         UInt32 inChannel,

  240.         Boolean	isInput,

  241.         AudioDevicePropertyID inPropertyID,

  242.         void* inClientData)

  243. {

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

  245. 

  246.     switch (inPropertyID) {

  247. 

  248.         case kAudioDevicePropertyNominalSampleRate: {

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

  250.             driver->fState = true;

  251.             break;

  252.         }

  253.     }

  254. 

  255.     return noErr;

  256. }

  257. 

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

  259. OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,

  260.         UInt32 inChannel,

  261.         Boolean	isInput,

  262.         AudioDevicePropertyID inPropertyID,

  263.         void* inClientData)

  264. {

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

  266.          

  267.     switch (inPropertyID) {

  268.         

  269.         case kAudioDeviceProcessorOverload: {

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

  271.             jack_time_t cur_time = GetMicroSeconds();

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

  273.             break;

  274.         }

  275.         

  276.         case kAudioDevicePropertyStreamConfiguration: {

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

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

  279.             driver->CloseAUHAL();

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

  281.             return kAudioHardwareUnsupportedOperationError;

  282.         }

  283.         

  284.         case kAudioDevicePropertyNominalSampleRate: {

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

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

  287.             driver->CloseAUHAL();

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

  289.             return kAudioHardwareUnsupportedOperationError;

  290. 		}

  291.             

  292.     }

  293.     return noErr;

  294. }

  295. 

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

  297. {

  298.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  301. 

  302.     if (inIUD == NULL) {

  303.         return kAudioHardwareUnspecifiedError;

  304.     } else {

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

  306.         CFRelease(inIUD);

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

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

  309.     }

  310. }

  311. 

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

  313. {

  314.     OSStatus res;

  315.     UInt32 theSize = sizeof(UInt32);

  316.     AudioDeviceID inDefault;

  317.     AudioDeviceID outDefault;

  318. 

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

  320.         return res;

  321. 

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

  323.         return res;

  324. 

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

  326. 

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

  328.     if (inDefault == outDefault) {

  329.         *id = inDefault;

  330.         return noErr;

  331.     } else {

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

  333.         return kAudioHardwareBadDeviceError;

  334.     }

  335. }

  336. 

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

  338. {

  339.     OSStatus res;

  340.     UInt32 theSize = sizeof(UInt32);

  341.     AudioDeviceID inDefault;

  342. 

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

  344.         return res;

  345. 

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

  347.     *id = inDefault;

  348.     return noErr;

  349. }

  350. 

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

  352. {

  353.     OSStatus res;

  354.     UInt32 theSize = sizeof(UInt32);

  355.     AudioDeviceID outDefault;

  356. 

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

  358.         return res;

  359. 

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

  361.     *id = outDefault;

  362.     return noErr;

  363. }

  364. 

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

  366. {

  367.     UInt32 size = 256;

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

  369. }

  370. 

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

  372. {

  373.     OSStatus err = noErr;

  374.     UInt32	outSize;

  375.     Boolean	outWritable;

  376.     AudioBufferList* bufferList = 0;

  377. 

  378.     channelCount = 0;

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

  380.     if (err == noErr) {

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

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

  383.         if (err == noErr) {

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

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

  386.         }

  387. 

  388.         if (bufferList)

  389.             free(bufferList);

  390.     }

  391. 

  392.     return err;

  393. }

  394. 

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

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

  397.         fJackInputData(NULL), 

  398.         fDriverOutputData(NULL), 

  399.         fPluginID(0), 

  400.         fState(false), 

  401.         fHogged(false),

  402.         fIOUsage(1.f),

  403.         fComputationGrain(-1.f)

  404. {}

  405. 

  406. JackCoreAudioDriver::~JackCoreAudioDriver()

  407. {}

  408. 

  409. OSStatus JackCoreAudioDriver::DestroyAggregateDevice() 

  410. {

  411.     OSStatus osErr = noErr;

  412.     AudioObjectPropertyAddress pluginAOPA;

  413.     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;

  414.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  415.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  416.     UInt32 outDataSize;

  417.      

  418.     if (fPluginID > 0)   {

  419.       

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

  421.         if (osErr != noErr) {

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

  423.             printError(osErr);

  424.             return osErr;

  425.         }

  426.             

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

  428.         if (osErr != noErr) {

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

  430.             printError(osErr);

  431.             return osErr;

  432.         }

  433.         

  434.     }

  435.     

  436.     return noErr;

  437. }

  438. 

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

  440. {

  441.     OSStatus osErr = noErr;

  442.     UInt32 outSize;

  443.     Boolean outWritable;

  444.     

  445.     // Check devices... (TO IMPROVE)

  446.     if (IsAggregateDevice(captureDeviceID) || IsAggregateDevice(playbackDeviceID)) {

  447.         jack_error("JackCoreAudioDriver::CreateAggregateDevice : cannot agregate devices that are already aggregate devices...");

  448.         return -1;

  449.     }

  450.     

  451.     //---------------------------------------------------------------------------

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

  453.     //---------------------------------------------------------------------------

  454.     if (SetupSampleRateAux(captureDeviceID, samplerate) < 0) {

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

  456.     }

  457.     if (SetupSampleRateAux(playbackDeviceID, samplerate) < 0) {

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

  459.     }

  460. 

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

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

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

  464.     

  465.     char capture_name[256];

  466.     char playback_name[256];

  467.     GetDeviceNameFromID(captureDeviceID, capture_name);

  468.     GetDeviceNameFromID(playbackDeviceID, playback_name);

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

  470.  

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

  472.     if (osErr != noErr) {

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

  474.         printError(osErr);

  475.         return osErr;

  476.     }

  477. 

  478.     AudioValueTranslation pluginAVT;

  479. 

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

  481.    

  482.     pluginAVT.mInputData = &inBundleRef;

  483.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  484.     pluginAVT.mOutputData = &fPluginID;

  485.     pluginAVT.mOutputDataSize = sizeof(fPluginID);

  486. 

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

  488.     if (osErr != noErr) {

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

  490.         printError(osErr);

  491.         return osErr;

  492.     }

  493. 

  494.     //-------------------------------------------------

  495.     // Create a CFDictionary for our aggregate device

  496.     //-------------------------------------------------

  497. 

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

  499. 

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

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

  502.     

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

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

  505. 

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

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

  508.     

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

  510.     int value = 1;

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

  512.     

  513.     SInt32 system;

  514.     Gestalt(gestaltSystemVersion, &system);

  515.      

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

  517.     

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

  519.     if (system < 0x00001054) {

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

  521.     } else {

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

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

  524.     }

  525.   

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

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

  528.     //-------------------------------------------------

  529.     

  530.     CFStringRef captureDeviceUID = GetDeviceName(captureDeviceID);

  531.     CFStringRef playbackDeviceUID = GetDeviceName(playbackDeviceID);

  532.     

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

  534.         return -1;

  535.   

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

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

  538. 

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

  540.     CFArrayAppendValue(subDevicesArray, captureDeviceUID);

  541.     CFArrayAppendValue(subDevicesArray, playbackDeviceUID);

  542. 

  543.     //-----------------------------------------------------------------------

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

  545.     //-----------------------------------------------------------------------

  546.  

  547.     AudioObjectPropertyAddress pluginAOPA;

  548.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  549.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  550.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  551.     UInt32 outDataSize;

  552. 

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

  554.     if (osErr != noErr) {

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

  556.         printError(osErr);

  557.         goto error;

  558.     }

  559.     

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

  561.     if (osErr != noErr) {

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

  563.         printError(osErr);

  564.         goto error;

  565.     }

  566. 

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

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

  569.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  570. 

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

  572.     // Set the sub-device list

  573.     //-------------------------

  574. 

  575.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  576.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  577.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  578.     outDataSize = sizeof(CFMutableArrayRef);

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

  580.     if (osErr != noErr) {

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

  582.         printError(osErr);

  583.         goto error;

  584.     }

  585.     

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

  587.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  588. 

  589.     //-----------------------

  590.     // Set the master device

  591.     //-----------------------

  592. 

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

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

  595.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  596.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  597.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  598.     outDataSize = sizeof(CFStringRef);

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

  600.     if (osErr != noErr) {

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

  602.         printError(osErr);

  603.         goto error;

  604.     }

  605.     

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

  607.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  608. 

  609.     //----------

  610.     // Clean up

  611.     //----------

  612.     

  613.     // release the private AD key

  614.     CFRelease(AggregateDeviceNumberRef);

  615. 

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

  617.     CFRelease(aggDeviceDict);

  618.     CFRelease(subDevicesArray);

  619. 

  620.     // release the device UID

  621.     CFRelease(captureDeviceUID);

  622.     CFRelease(playbackDeviceUID);

  623.     

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

  625.     return noErr;

  626.     

  627. error:

  628.     DestroyAggregateDevice();

  629.     return -1;

  630. }

  631. 

  632. int JackCoreAudioDriver::SetupDevices(const char* capture_driver_uid, const char* playback_driver_uid, char* capture_driver_name, char* playback_driver_name, jack_nframes_t samplerate)

  633. {

  634.     capture_driver_name[0] = 0;

  635.     playback_driver_name[0] = 0;

  636. 

  637.     // Duplex

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

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

  640.           

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

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

  643.             

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

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

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

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

  648.                     return -1;

  649.                 }

  650.             }

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

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

  653.                 return -1;

  654.             }

  655.             

  656.         } else {

  657.         

  658.             // Creates aggregate device

  659.             AudioDeviceID captureID, playbackID;

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

  661.                 return -1;

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

  663.                 return -1;

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

  665.                 return -1;

  666.         }

  667. 

  668.     // Capture only

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

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

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

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

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

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

  675.                 return -1;

  676.             }

  677.         }

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

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

  680.             return -1;

  681.         }

  682. 

  683.     // Playback only

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

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

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

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

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

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

  690.                 return -1;

  691.             }

  692.         }

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

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

  695.             return -1;

  696.         }

  697. 

  698.     // Use default driver in duplex mode

  699.     } else {

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

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

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

  703.             return -1;

  704.         }

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

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

  707.             return -1;

  708.         }

  709.     }

  710.     

  711.     if (fHogged) {

  712.         if (TakeHog()) {

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

  714.         } else {

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

  716.         }

  717.     }

  718. 

  719.     return 0;

  720. }

  721. 

  722. /*

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

  724. */

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

  726. {

  727.     OSStatus err = noErr;

  728. 

  729.     if (capturing) {

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

  731.         if (err != noErr) {

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

  733.             printError(err);

  734.             return -1;

  735.         } else {

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

  737.         }

  738.     }

  739. 

  740.     if (playing) {

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

  742.         if (err != noErr) {

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

  744.             printError(err);

  745.             return -1;

  746.         } else {

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

  748.         }

  749.     }

  750. 

  751.     if (inchannels > in_nChannels) {

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

  753.         if (strict)

  754.             return -1;

  755.     }

  756. 

  757.     if (outchannels > out_nChannels) {

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

  759.         if (strict)

  760.             return -1;

  761.     }

  762. 

  763.     if (inchannels == 0) {

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

  765.         inchannels = in_nChannels;

  766.     }

  767. 

  768.     if (outchannels == 0) {

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

  770.         outchannels = out_nChannels;

  771.     }

  772. 

  773.     return 0;

  774. }

  775. 

  776. int JackCoreAudioDriver::SetupBufferSize(jack_nframes_t buffer_size)

  777. {

  778.     // Setting buffer size

  779.     UInt32 outSize = sizeof(UInt32);

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

  781.     if (err != noErr) {

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

  783.         printError(err);

  784.         return -1;

  785.     }

  786. 

  787.     return 0;

  788. }

  789. 

  790. int JackCoreAudioDriver::SetupSampleRate(jack_nframes_t samplerate)

  791. {

  792.     return SetupSampleRateAux(fDeviceID, samplerate);

  793. }

  794. 

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

  796. {

  797.     OSStatus err = noErr;

  798.     UInt32 outSize;

  799.     Float64 sampleRate;

  800. 

  801.     // Get sample rate

  802.     outSize =  sizeof(Float64);

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

  804.     if (err != noErr) {

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

  806.         printError(err);

  807.         return -1;

  808.     }

  809. 

  810.     // If needed, set new sample rate

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

  812.         sampleRate = (Float64)samplerate;

  813. 

  814.         // To get SR change notification

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

  816.         if (err != noErr) {

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

  818.             printError(err);

  819.             return -1;

  820.         }

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

  822.         if (err != noErr) {

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

  824.             printError(err);

  825.             return -1;

  826.         }

  827. 

  828.         // Waiting for SR change notification

  829.         int count = 0;

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

  831.             usleep(100000);

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

  833.         }

  834. 

  835.         // Remove SR change notification

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

  837.     }

  838. 

  839.     return 0;

  840. }

  841. 

  842. 

  843. int JackCoreAudioDriver::OpenAUHAL(bool capturing,

  844.                                    bool playing,

  845.                                    int inchannels,

  846.                                    int outchannels,

  847.                                    int in_nChannels,

  848.                                    int out_nChannels,

  849.                                    jack_nframes_t buffer_size,

  850.                                    jack_nframes_t samplerate,

  851.                                    bool strict)

  852. {

  853.     ComponentResult err1;

  854.     UInt32 enableIO;

  855.     AudioStreamBasicDescription srcFormat, dstFormat;

  856. 

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

  858. 

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

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

  861.         return -1;

  862.     }

  863.          

  864.     // AUHAL

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

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

  867. 

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

  869.     if (err1 != noErr) {

  870.         jack_error("Error calling OpenAComponent");

  871.         printError(err1);

  872.         return -1;

  873.     }

  874. 

  875.     err1 = AudioUnitInitialize(fAUHAL);

  876.     if (err1 != noErr) {

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

  878.         printError(err1);

  879.         return -1;

  880.     }

  881. 

  882.     // Start I/O

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

  884.         enableIO = 1;

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

  886.     } else {

  887.         enableIO = 0;

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

  889.     }

  890.     

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

  892.     if (err1 != noErr) {

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

  894.         printError(err1);

  895.         if (strict)

  896.             return -1;

  897.     }

  898. 

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

  900.         enableIO = 1;

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

  902.     } else {

  903.         enableIO = 0;

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

  905.     }

  906.     

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

  908.     if (err1 != noErr) {

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

  910.         printError(err1);

  911.         if (strict)

  912.             return -1;

  913.     }

  914.     

  915.     AudioDeviceID currAudioDeviceID;

  916.     UInt32 size = sizeof(AudioDeviceID);

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

  918.     if (err1 != noErr) {

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

  920.         printError(err1);

  921.         if (strict)

  922.             return -1;

  923.     } else {

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

  925.     }

  926. 

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

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

  929.     if (err1 != noErr) {

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

  931.         printError(err1);

  932.         if (strict)

  933.             return -1;

  934.     }

  935.   

  936.     // Set buffer size

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

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

  939.         if (err1 != noErr) {

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

  941.             printError(err1);

  942.             if (strict)

  943.                 return -1;

  944.         }

  945.     }

  946. 

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

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

  949.         if (err1 != noErr) {

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

  951.             printError(err1);

  952.             if (strict)

  953.                 return -1;

  954.         }

  955.     }

  956. 

  957.     // Setup channel map

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

  959.         SInt32 chanArr[in_nChannels];

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

  961.             chanArr[i] = -1;

  962.         }

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

  964.             chanArr[i] = i;

  965.         }

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

  967.         if (err1 != noErr) {

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

  969.             printError(err1);

  970.         }

  971.     }

  972. 

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

  974.         SInt32 chanArr[out_nChannels];

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

  976.             chanArr[i] = -1;

  977.         }

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

  979.             chanArr[i] = i;

  980.         }

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

  982.         if (err1 != noErr) {

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

  984.             printError(err1);

  985.         }

  986.     }

  987. 

  988.     // Setup stream converters

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

  990.     srcFormat.mSampleRate = samplerate;

  991.     srcFormat.mFormatID = kAudioFormatLinearPCM;

  992.     srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  993.     srcFormat.mBytesPerPacket = sizeof(float);

  994.     srcFormat.mFramesPerPacket = 1;

  995.     srcFormat.mBytesPerFrame = sizeof(float);

  996.     srcFormat.mChannelsPerFrame = outchannels;

  997.     srcFormat.mBitsPerChannel = 32;

  998. 

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

  1000.     if (err1 != noErr) {

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

  1002.         printError(err1);

  1003.     }

  1004. 

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

  1006.     dstFormat.mSampleRate = samplerate;

  1007.     dstFormat.mFormatID = kAudioFormatLinearPCM;

  1008.     dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1009.     dstFormat.mBytesPerPacket = sizeof(float);

  1010.     dstFormat.mFramesPerPacket = 1;

  1011.     dstFormat.mBytesPerFrame = sizeof(float);

  1012.     dstFormat.mChannelsPerFrame = inchannels;

  1013.     dstFormat.mBitsPerChannel = 32;

  1014. 

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

  1016.     if (err1 != noErr) {

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

  1018.         printError(err1);

  1019.     }

  1020. 

  1021.     // Setup callbacks

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

  1023.         AURenderCallbackStruct output;

  1024.         output.inputProc = Render;

  1025.         output.inputProcRefCon = this;

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

  1027.         if (err1 != noErr) {

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

  1029.             printError(err1);

  1030.             return -1;

  1031.         }

  1032.     } else {

  1033.         AURenderCallbackStruct output;

  1034.         output.inputProc = Render;

  1035.         output.inputProcRefCon = this;

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

  1037.         if (err1 != noErr) {

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

  1039.             printError(err1);

  1040.             return -1;

  1041.         }

  1042.     }

  1043. 

  1044.     return 0;

  1045. }

  1046. 

  1047. int JackCoreAudioDriver::SetupBuffers(int inchannels)

  1048. {

  1049.     // Prepare buffers

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

  1051.     if (fJackInputData == 0) {

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

  1053.         return -1;

  1054.     }

  1055.     fJackInputData->mNumberBuffers = inchannels;

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

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

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

  1059.     }

  1060.     return 0;

  1061. }

  1062. 

  1063. void JackCoreAudioDriver::DisposeBuffers()

  1064. {

  1065.     if (fJackInputData) {

  1066.         free(fJackInputData);

  1067.         fJackInputData = 0;

  1068.     }

  1069. }

  1070. 

  1071. void JackCoreAudioDriver::CloseAUHAL()

  1072. {

  1073.     AudioUnitUninitialize(fAUHAL);

  1074.     CloseComponent(fAUHAL);

  1075. }

  1076. 

  1077. int JackCoreAudioDriver::AddListeners()

  1078. {

  1079.     OSStatus err = noErr;

  1080. 

  1081.     // Add listeners

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

  1083.     if (err != noErr) {

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

  1085.         printError(err);

  1086.         return -1;

  1087.     }

  1088. 

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

  1090.     if (err != noErr) {

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

  1092.         printError(err);

  1093.         return -1;

  1094.     }

  1095. 

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

  1097.     if (err != noErr) {

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

  1099.         printError(err);

  1100.         return -1;

  1101.     }

  1102. 

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

  1104.     if (err != noErr) {

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

  1106.         printError(err);

  1107.         return -1;

  1108.     }

  1109. 

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

  1111.     if (err != noErr) {

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

  1113.         printError(err);

  1114.         return -1;

  1115.     }

  1116. 

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

  1118.     if (err != noErr) {

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

  1120.         printError(err);

  1121.         return -1;

  1122.     }

  1123. 

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

  1125.         UInt32 outSize = sizeof(float);

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

  1127.         if (err != noErr) {

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

  1129.             printError(err);

  1130.         }

  1131.     }

  1132. 

  1133.     return 0;

  1134. }

  1135. 

  1136. void JackCoreAudioDriver::RemoveListeners()

  1137. {

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

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

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

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

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

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

  1144. }

  1145. 

  1146. int JackCoreAudioDriver::Open(jack_nframes_t buffer_size,

  1147.                               jack_nframes_t samplerate,

  1148.                               bool capturing,

  1149.                               bool playing,

  1150.                               int inchannels,

  1151.                               int outchannels,

  1152.                               bool monitor,

  1153.                               const char* capture_driver_uid,

  1154.                               const char* playback_driver_uid,

  1155.                               jack_nframes_t capture_latency,

  1156.                               jack_nframes_t playback_latency,

  1157.                               int async_output_latency,

  1158.                               int computation_grain,

  1159.                               bool hogged)

  1160. {

  1161.     int in_nChannels = 0;

  1162.     int out_nChannels = 0;

  1163.     char capture_driver_name[256];

  1164.     char playback_driver_name[256];

  1165. 

  1166.     // Keep initial state

  1167.     fCapturing = capturing;

  1168.     fPlaying = playing;

  1169.     fInChannels = inchannels;

  1170.     fOutChannels = outchannels;

  1171.     fMonitor = monitor;

  1172.     strcpy(fCaptureUID, capture_driver_uid);

  1173.     strcpy(fPlaybackUID, playback_driver_uid);

  1174.     fCaptureLatency = capture_latency;

  1175.     fPlaybackLatency = playback_latency;

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

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

  1178.     fHogged = hogged;

  1179.     

  1180.     SInt32 major;

  1181.     SInt32 minor;

  1182.     Gestalt(gestaltSystemVersionMajor, &major);

  1183.     Gestalt(gestaltSystemVersionMinor, &minor);

  1184.     

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

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

  1187.         CFRunLoopRef theRunLoop = NULL;

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

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

  1190.         if (theError != noErr) {

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

  1192.         }

  1193.     }

  1194. 

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

  1196.         goto error;

  1197. 

  1198.     // Generic JackAudioDriver Open

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

  1200.         goto error;

  1201. 

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

  1203.         goto error;

  1204. 

  1205.     if (SetupBufferSize(buffer_size)  < 0)

  1206.         goto error;

  1207.         

  1208.     if (SetupSampleRate(samplerate) < 0)

  1209.         goto error;

  1210.  

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

  1212.         goto error;

  1213. 

  1214.     if (capturing && inchannels > 0)

  1215.         if (SetupBuffers(inchannels) < 0)

  1216.             goto error;

  1217. 

  1218.     if (AddListeners() < 0)

  1219.         goto error;

  1220.   

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

  1222.     fCaptureChannels = inchannels;

  1223.     fPlaybackChannels = outchannels;

  1224.     return noErr;

  1225. 

  1226. error:

  1227.     Close();

  1228.     return -1;

  1229. }

  1230. 

  1231. int JackCoreAudioDriver::Close()

  1232. {

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

  1234.     Stop();

  1235.     JackAudioDriver::Close();

  1236.     RemoveListeners();

  1237.     DisposeBuffers();

  1238.     CloseAUHAL();

  1239.     DestroyAggregateDevice();

  1240.     return 0;

  1241. }

  1242. 

  1243. int JackCoreAudioDriver::Attach()

  1244. {

  1245.     OSStatus err;

  1246.     JackPort* port;

  1247.     jack_port_id_t port_index;

  1248.     UInt32 size;

  1249.     Boolean isWritable;

  1250.     char channel_name[64];

  1251.     char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  1252.     char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

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

  1254. 

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

  1256. 

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

  1258. 

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

  1260.         if (err != noErr)

  1261.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

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

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

  1264.             if (err != noErr)

  1265.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

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

  1267.         } else {

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

  1269.         }

  1270. 

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

  1272. 

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

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

  1275.             return -1;

  1276.         }

  1277. 

  1278.         size = sizeof(UInt32);

  1279.         UInt32 value1 = 0;

  1280.         UInt32 value2 = 0;

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

  1282.         if (err != noErr)

  1283.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

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

  1285.         if (err != noErr)

  1286.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  1287. 

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

  1289.         port->SetAlias(alias);

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

  1291.         fCapturePortList[i] = port_index;

  1292.     }

  1293. 

  1294.     port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  1295. 

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

  1297. 

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

  1299.         if (err != noErr)

  1300.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

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

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

  1303.             if (err != noErr)

  1304.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

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

  1306.         } else {

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

  1308.         }

  1309. 

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

  1311. 

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

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

  1314.             return -1;

  1315.         }

  1316. 

  1317.         size = sizeof(UInt32);

  1318.         UInt32 value1 = 0;

  1319.         UInt32 value2 = 0;

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

  1321.         if (err != noErr)

  1322.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

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

  1324.         if (err != noErr)

  1325.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  1326. 

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

  1328.         port->SetAlias(alias);

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

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

  1331.         fPlaybackPortList[i] = port_index;

  1332. 

  1333.         // Monitor ports

  1334.         if (fWithMonitorPorts) {

  1335.             jack_log("Create monitor port ");

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

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

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

  1339.                 return -1;

  1340.             } else {

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

  1342.                 port->SetAlias(alias);

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

  1344.                 fMonitorPortList[i] = port_index;

  1345.             }

  1346.         }

  1347.     }

  1348. 

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

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

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

  1352.     }

  1353. 

  1354.     return 0;

  1355. }

  1356. 

  1357. int JackCoreAudioDriver::Start()

  1358. {

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

  1360.     JackAudioDriver::Start();

  1361. /*

  1362. #ifdef MAC_OS_X_VERSION_10_5

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

  1364. #else

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

  1366. #endif

  1367. */

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

  1369.     

  1370.     if (err != noErr)

  1371.         return -1;

  1372. 

  1373.     err = AudioOutputUnitStart(fAUHAL);

  1374.     if (err != noErr)

  1375.         return -1;

  1376. 

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

  1378.         jack_error("Cannot start MeasureCallback");

  1379.         printError(err);

  1380.         return -1;

  1381.     }

  1382.     

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

  1384.     fState = false;

  1385.     int count = 0;

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

  1387.         usleep(100000);

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

  1389.     }

  1390.     

  1391.     if (count < WAIT_COUNTER) {

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

  1393.         return 0;

  1394.     } else {

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

  1396.         return -1;

  1397.     }

  1398. }

  1399. 

  1400. int JackCoreAudioDriver::Stop()

  1401. {

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

  1403.     AudioDeviceStop(fDeviceID, MeasureCallback);

  1404. /*

  1405. #ifdef MAC_OS_X_VERSION_10_5

  1406.     AudioDeviceDestroyIOProcID(fDeviceID, fMesureCallbackID);

  1407. #else

  1408.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

  1409. #endif

  1410. */

  1411.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

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

  1413. }

  1414. 

  1415. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  1416. {

  1417.     OSStatus err;

  1418.     UInt32 outSize = sizeof(UInt32);

  1419. 

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

  1421.     if (err != noErr) {

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

  1423.         printError(err);

  1424.         return -1;

  1425.     }

  1426. 

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

  1428. 

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

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

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

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

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

  1434.     }

  1435. 

  1436.     return 0;

  1437. }

  1438. 

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

  1440. {

  1441.     pid_t hog_pid;

  1442.     OSStatus err;

  1443. 

  1444.     UInt32 propSize = sizeof(hog_pid);

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

  1446.     if (err) {

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

  1448.         printError(err);

  1449.     }

  1450. 

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

  1452.         hog_pid = getpid();

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

  1454.         if (err != noErr) {

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

  1456.             return false;

  1457.         }

  1458.     }

  1459.     

  1460.     return true;

  1461. }

  1462.     

  1463. bool JackCoreAudioDriver::TakeHog()

  1464. {

  1465.     OSStatus err = noErr;

  1466.     AudioObjectID sub_device[32];

  1467.     UInt32 outSize = sizeof(sub_device);

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

  1469.     

  1470.     if (err != noErr) {

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

  1472.         return TakeHogAux(fDeviceID, true);

  1473.     } else {

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

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

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

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

  1478.                 return false;

  1479.             }

  1480.         }

  1481.         return true;

  1482.     }

  1483. }

  1484.     

  1485. bool JackCoreAudioDriver::IsAggregateDevice(AudioDeviceID device)

  1486. {

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

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

  1489.     

  1490.     if (err != noErr) {

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

  1492.         return false;

  1493.     } else {

  1494.         return (deviceType == kAudioDeviceTransportTypeAggregate);

  1495.     }

  1496. }

  1497. 

  1498. 

  1499. } // end of namespace

  1500. 

  1501. 

  1502. #ifdef __cplusplus

  1503. extern "C"

  1504. {

  1505. #endif

  1506. 

  1507.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor() 

  1508.     {

  1509.         jack_driver_desc_t *desc;

  1510.         unsigned int i;

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

  1512. 

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

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

  1515.         

  1516.         desc->nparams = 16;

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

  1518. 

  1519.         i = 0;

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

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

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

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

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

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

  1526. 

  1527.         i++;

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

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

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

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

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

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

  1534. 

  1535.         i++;

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

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

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

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

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

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

  1542. 

  1543.         i++;

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

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

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

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

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

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

  1550. 

  1551.         i++;

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

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

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

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

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

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

  1558. 

  1559.         i++;

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

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

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

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

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

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

  1566. 

  1567.         i++;

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

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

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

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

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

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

  1574. 

  1575.         i++;

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

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

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

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

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

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

  1582. 

  1583.         i++;

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

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

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

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

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

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

  1590. 

  1591.         i++;

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

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

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

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

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

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

  1598. 

  1599.         i++;

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

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

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

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

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

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

  1606. 

  1607.         i++;

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

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

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

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

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

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

  1614. 

  1615.         i++;

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

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

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

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

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

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

  1622.         

  1623.         i++;

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

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

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

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

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

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

  1630.         

  1631.         i++;

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

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

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

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

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

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

  1638.         

  1639.         i++;

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

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

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

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

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

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

  1646. 

  1647.         return desc;

  1648.     }

  1649. 

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

  1651.     {

  1652.         jack_nframes_t srate = 44100;

  1653.         jack_nframes_t frames_per_interrupt = 128;

  1654.         int capture = FALSE;

  1655.         int playback = FALSE;

  1656.         int chan_in = 0;

  1657.         int chan_out = 0;

  1658.         bool monitor = false;

  1659.         const char* capture_driver_uid = "";

  1660.         const char* playback_driver_uid = "";

  1661.         const JSList *node;

  1662.         const jack_driver_param_t *param;

  1663.         jack_nframes_t systemic_input_latency = 0;

  1664.         jack_nframes_t systemic_output_latency = 0;

  1665.         int async_output_latency = 100;

  1666.         int computation_grain = -1;

  1667.         bool hogged = false;

  1668.     

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

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

  1671.        

  1672.             switch (param->character) {

  1673. 

  1674.                 case 'd':

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

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

  1677.                     break;

  1678. 

  1679.                 case 'D':

  1680.                     capture = TRUE;

  1681.                     playback = TRUE;

  1682.                     break;

  1683. 

  1684.                 case 'c':

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

  1686.                     break;

  1687. 

  1688.                 case 'i':

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

  1690.                     break;

  1691. 

  1692.                 case 'o':

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

  1694.                     break;

  1695. 

  1696.                 case 'C':

  1697.                     capture = TRUE;

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

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

  1700.                     }

  1701.                     break;

  1702. 

  1703.                 case 'P':

  1704.                     playback = TRUE;

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

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

  1707.                     }

  1708.                     break;

  1709. 

  1710.                 case 'm':

  1711.                     monitor = param->value.i;

  1712.                     break;

  1713. 

  1714.                 case 'r':

  1715.                     srate = param->value.ui;

  1716.                     break;

  1717. 

  1718.                 case 'p':

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

  1720.                     break;

  1721. 

  1722.                 case 'I':

  1723.                     systemic_input_latency = param->value.ui;

  1724.                     break;

  1725. 

  1726.                 case 'O':

  1727.                     systemic_output_latency = param->value.ui;

  1728.                     break;

  1729. 

  1730.                 case 'l':

  1731.                     Jack::DisplayDeviceNames();

  1732.                     break;

  1733.                     

  1734.                 case 'H':

  1735.                     hogged = true;

  1736.                     break;

  1737.                     

  1738.                 case 'L':

  1739.                     async_output_latency = param->value.ui;

  1740.                     break;

  1741.                     

  1742.                 case 'G':

  1743.                     computation_grain = param->value.ui;

  1744.                     break;

  1745.             }

  1746.         }

  1747. 

  1748.         /* duplex is the default */

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

  1750.             capture = TRUE;

  1751.             playback = TRUE;

  1752.         }

  1753. 

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

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

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

  1757.             return driver;

  1758.         } else {

  1759.             delete driver;

  1760.             return NULL;

  1761.         }

  1762.     }

  1763. 

  1764. #ifdef __cplusplus

  1765. }

  1766. #endif

  1767.