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

2266 lines
88KB
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. #include "JackLockedEngine.h"

  31. 

  32. #include <sstream>

  33. #include <iostream>

  34. #include <CoreServices/CoreServices.h>

  35. #include <CoreFoundation/CFNumber.h>

  36. 

  37. namespace Jack

  38. {

  39. 

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

  41. {

  42.     UInt32 __4CC_number = (c);

  43.     char __4CC_string[5];

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

  45.     __4CC_string[4] = 0;

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

  47. }

  48. 

  49. static void PrintStreamDesc(AudioStreamBasicDescription *inDesc)

  50. {

  51.     jack_log("- - - - - - - - - - - - - - - - - - - -");

  52.     jack_log("  Sample Rate:%f", inDesc->mSampleRate);

  53.     jack_log("  Format ID:%.*s", (int) sizeof(inDesc->mFormatID), (char*)&inDesc->mFormatID);

  54.     jack_log("  Format Flags:%lX", inDesc->mFormatFlags);

  55.     jack_log("  Bytes per Packet:%ld", inDesc->mBytesPerPacket);

  56.     jack_log("  Frames per Packet:%ld", inDesc->mFramesPerPacket);

  57.     jack_log("  Bytes per Frame:%ld", inDesc->mBytesPerFrame);

  58.     jack_log("  Channels per Frame:%ld", inDesc->mChannelsPerFrame);

  59.     jack_log("  Bits per Channel:%ld", inDesc->mBitsPerChannel);

  60.     jack_log("- - - - - - - - - - - - - - - - - - - -");

  61. }

  62. 

  63. static void printError(OSStatus err)

  64. {

  65.     switch (err) {

  66.         case kAudioHardwareNoError:

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

  68.             break;

  69.         case kAudioConverterErr_FormatNotSupported:

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

  71.             break;

  72.         case kAudioConverterErr_OperationNotSupported:

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

  74.             break;

  75.         case kAudioConverterErr_PropertyNotSupported:

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

  77.             break;

  78.         case kAudioConverterErr_InvalidInputSize:

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

  80.             break;

  81.         case kAudioConverterErr_InvalidOutputSize:

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

  83.             break;

  84.         case kAudioConverterErr_UnspecifiedError:

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

  86.             break;

  87.         case kAudioConverterErr_BadPropertySizeError:

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

  89.             break;

  90.         case kAudioConverterErr_RequiresPacketDescriptionsError:

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

  92.             break;

  93.         case kAudioConverterErr_InputSampleRateOutOfRange:

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

  95.             break;

  96.         case kAudioConverterErr_OutputSampleRateOutOfRange:

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

  98.             break;

  99.         case kAudioHardwareNotRunningError:

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

  101.             break;

  102.         case kAudioHardwareUnknownPropertyError:

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

  104.             break;

  105.         case kAudioHardwareIllegalOperationError:

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

  107.             break;

  108.         case kAudioHardwareBadDeviceError:

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

  110.             break;

  111.         case kAudioHardwareBadStreamError:

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

  113.             break;

  114.         case kAudioDeviceUnsupportedFormatError:

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

  116.             break;

  117.         case kAudioDevicePermissionsError:

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

  119.             break;

  120.         case kAudioHardwareBadObjectError:

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

  122.             break;

  123.         case kAudioHardwareUnsupportedOperationError:

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

  125.             break;

  126.         default:

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

  128.             break;

  129.     }

  130. }

  131. 

  132. static OSStatus DisplayDeviceNames()

  133. {

  134.     UInt32 size;

  135.     Boolean isWritable;

  136.     int i, deviceNum;

  137.     OSStatus err;

  138.     CFStringRef UIname;

  139. 

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

  141.     if (err != noErr) {

  142.         return err;

  143.     }

  144. 

  145.     deviceNum = size / sizeof(AudioDeviceID);

  146.     AudioDeviceID devices[deviceNum];

  147. 

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

  149.     if (err != noErr) {

  150.         return err;

  151.     }

  152. 

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

  154.         char device_name[256];

  155.         char internal_name[256];

  156. 

  157.         size = sizeof(CFStringRef);

  158.         UIname = NULL;

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

  160.         if (err == noErr) {

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

  162.         } else {

  163.             goto error;

  164.         }

  165. 

  166.         size = 256;

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

  168.         if (err != noErr) {

  169.             return err;

  170.         }

  171. 

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

  173.     }

  174. 

  175.     return noErr;

  176. 

  177. error:

  178.     if (UIname != NULL) {

  179.         CFRelease(UIname);

  180.     }

  181.     return err;

  182. }

  183. 

  184. static CFStringRef GetDeviceName(AudioDeviceID id)

  185. {

  186.     UInt32 size = sizeof(CFStringRef);

  187.     CFStringRef UIname;

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

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

  190. }

  191. 

  192. static void ParseChannelList(const string& list, vector<int>& result)

  193. {

  194.     stringstream ss(list);

  195.     string token;

  196. 	int chan;

  197. 

  198.     while (ss >> token) {

  199.         istringstream ins;

  200.         ins.str(token);

  201.         ins >> chan;

  202.         result.push_back(chan);

  203.     }

  204. }

  205. 

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

  207.                                      AudioUnitRenderActionFlags *ioActionFlags,

  208.                                      const AudioTimeStamp *inTimeStamp,

  209.                                      UInt32 inBusNumber,

  210.                                      UInt32 inNumberFrames,

  211.                                      AudioBufferList *ioData)

  212. {

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

  214.     driver->fActionFags = ioActionFlags;

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

  216.     driver->fDriverOutputData = ioData;

  217. 

  218.     // Setup threaded based log function et get RT thread parameters once...

  219.     if (set_threaded_log_function()) {

  220. 

  221.         jack_log("set_threaded_log_function");

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

  223. 

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

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

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

  227.         }

  228.     }

  229. 

  230.     // Signal waiting start function...

  231.     driver->fState = true;

  232. 

  233.     driver->CycleTakeBeginTime();

  234. 

  235.     if (driver->Process() < 0) {

  236.         jack_error("Process error, stopping driver.");

  237.         driver->NotifyFailure(JackBackendError, "Process error, stopping driver.");    // Message length limited to JACK_MESSAGE_SIZE

  238.         driver->Stop();

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

  240.         return kAudioHardwareUnsupportedOperationError;

  241.     } else {

  242.         return noErr;

  243.     }

  244. }

  245. 

  246. int JackCoreAudioDriver::Read()

  247. {

  248.     if (fCaptureChannels > 0)  { // Calling AudioUnitRender with no input returns a '????' error (callback setting issue ??), so hack to avoid it here...

  249.         return (AudioUnitRender(fAUHAL, fActionFags, fCurrentTime, 1, fEngineControl->fBufferSize, fJackInputData) == noErr) ? 0 : -1;

  250.     } else {

  251.         return 0;

  252.     }

  253. }

  254. 

  255. int JackCoreAudioDriver::Write()

  256. {

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

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

  259.             jack_default_audio_sample_t* buffer = GetOutputBuffer(i);

  260.             int size = sizeof(jack_default_audio_sample_t) * fEngineControl->fBufferSize;

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

  262.             // Monitor ports

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

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

  265.             }

  266.         } else {

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

  268.         }

  269.     }

  270.     return 0;

  271. }

  272. 

  273. OSStatus JackCoreAudioDriver::SRNotificationCallback(AudioDeviceID inDevice,

  274.                                                     UInt32 inChannel,

  275.                                                     Boolean	isInput,

  276.                                                     AudioDevicePropertyID inPropertyID,

  277.                                                     void* inClientData)

  278. {

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

  280. 

  281.     switch (inPropertyID) {

  282. 

  283.         case kAudioDevicePropertyNominalSampleRate: {

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

  285.             // Check new sample rate

  286.             Float64 tmp_sample_rate;

  287.             UInt32 outSize =  sizeof(Float64);

  288.             OSStatus err = AudioDeviceGetProperty(inDevice, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &tmp_sample_rate);

  289.             if (err != noErr) {

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

  291.                 printError(err);

  292.             } else {

  293.                 jack_log("SRNotificationCallback : checked sample rate = %f", tmp_sample_rate);

  294.             }

  295.             driver->fState = true;

  296.             break;

  297.         }

  298.     }

  299. 

  300.     return noErr;

  301. }

  302. 

  303. OSStatus JackCoreAudioDriver::BSNotificationCallback(AudioDeviceID inDevice,

  304.                                                      UInt32 inChannel,

  305.                                                      Boolean	isInput,

  306.                                                      AudioDevicePropertyID inPropertyID,

  307.                                                      void* inClientData)

  308. {

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

  310. 

  311.     switch (inPropertyID) {

  312. 

  313.         case kAudioDevicePropertyBufferFrameSize: {

  314.             jack_log("JackCoreAudioDriver::BSNotificationCallback kAudioDevicePropertyBufferFrameSize");

  315.             // Check new buffer size

  316.             UInt32 tmp_buffer_size;

  317.             UInt32 outSize =  sizeof(UInt32);

  318.             OSStatus err = AudioDeviceGetProperty(inDevice, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyBufferFrameSize, &outSize, &tmp_buffer_size);

  319.             if (err != noErr) {

  320.                 jack_error("Cannot get current buffer size");

  321.                 printError(err);

  322.             } else {

  323.                 jack_log("BSNotificationCallback : checked buffer size = %d", tmp_buffer_size);

  324.             }

  325.             driver->fState = true;

  326.             break;

  327.         }

  328.     }

  329. 

  330.     return noErr;

  331. }

  332. 

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

  334. OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,

  335.                                                         UInt32 inChannel,

  336.                                                         Boolean	isInput,

  337.                                                         AudioDevicePropertyID inPropertyID,

  338.                                                         void* inClientData)

  339. {

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

  341. 

  342.     switch (inPropertyID) {

  343. 

  344.         case kAudioDevicePropertyDeviceIsRunning: {

  345.             UInt32 isrunning = 0;

  346.             UInt32 outsize = sizeof(UInt32);

  347.             if (AudioDeviceGetProperty(driver->fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyDeviceIsRunning, &outsize, &isrunning) == noErr) {

  348.                 jack_log("JackCoreAudioDriver::DeviceNotificationCallback kAudioDevicePropertyDeviceIsRunning = %d", isrunning);

  349.             }

  350.             break;

  351.         }

  352. 

  353.         case kAudioDeviceProcessorOverload: {

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

  355.             jack_time_t cur_time = GetMicroSeconds();

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

  357.             break;

  358.         }

  359. 

  360.         case kAudioDevicePropertyStreamConfiguration: {

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

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

  363.             driver->CloseAUHAL();

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

  365.             return kAudioHardwareUnsupportedOperationError;

  366.         }

  367. 

  368.         case kAudioDevicePropertyNominalSampleRate: {

  369.             Float64 sample_rate = 0;

  370.             UInt32 outsize = sizeof(Float64);

  371.             OSStatus err = AudioDeviceGetProperty(driver->fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outsize, &sample_rate);

  372.             if (err != noErr) {

  373.                 return kAudioHardwareUnsupportedOperationError;

  374.             }

  375. 

  376.             char device_name[256];

  377.             const char* digidesign_name = "Digidesign";

  378.             driver->GetDeviceNameFromID(driver->fDeviceID, device_name);

  379. 

  380.             if (sample_rate != driver->fEngineControl->fSampleRate) {

  381. 

  382.                // Digidesign hardware, so "special" code : change the SR again here

  383.                if (strncmp(device_name, digidesign_name, 10) == 0) {

  384. 

  385.                     jack_log("Digidesign HW = %s", device_name);

  386. 

  387.                     // Set sample rate again...

  388.                     sample_rate = driver->fEngineControl->fSampleRate;

  389.                     err = AudioDeviceSetProperty(driver->fDeviceID, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, outsize, &sample_rate);

  390.                     if (err != noErr) {

  391.                         jack_error("Cannot set sample rate = %f", sample_rate);

  392.                         printError(err);

  393.                     } else {

  394.                         jack_log("Set sample rate = %f", sample_rate);

  395.                     }

  396. 

  397.                     // Check new sample rate again...

  398.                     outsize = sizeof(Float64);

  399.                     err = AudioDeviceGetProperty(inDevice, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outsize, &sample_rate);

  400.                     if (err != noErr) {

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

  402.                         printError(err);

  403.                     } else {

  404.                         jack_log("Checked sample rate = %f", sample_rate);

  405.                     }

  406.                     return noErr;

  407. 

  408.                 } else {

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

  410.                     driver->CloseAUHAL();

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

  412.                     return kAudioHardwareUnsupportedOperationError;

  413.                 }

  414.             }

  415.         }

  416. 

  417.     }

  418.     return noErr;

  419. }

  420. 

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

  422. {

  423.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  426. 

  427.     if (inIUD == NULL) {

  428.         return kAudioHardwareUnspecifiedError;

  429.     } else {

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

  431.         CFRelease(inIUD);

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

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

  434.     }

  435. }

  436. 

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

  438. {

  439.     OSStatus res;

  440.     UInt32 theSize = sizeof(UInt32);

  441.     AudioDeviceID inDefault;

  442.     AudioDeviceID outDefault;

  443. 

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

  445.         return res;

  446.     }

  447. 

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

  449.         return res;

  450.     }

  451. 

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

  453. 

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

  455.     if (inDefault != outDefault) {

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

  457.         return kAudioHardwareBadDeviceError;

  458.     } else if (inDefault == 0) {

  459.         jack_error("Default input and output devices are null !!");

  460.         return kAudioHardwareBadDeviceError;

  461.     } else {

  462.         *id = inDefault;

  463.         return noErr;

  464.     }

  465. }

  466. 

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

  468. {

  469.     OSStatus res;

  470.     UInt32 theSize = sizeof(UInt32);

  471.     AudioDeviceID inDefault;

  472. 

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

  474.         return res;

  475.     }

  476. 

  477.     if (inDefault == 0) {

  478.         jack_error("Error : input device is 0, please select a correct one !!");

  479.         return -1;

  480.     }

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

  482.     *id = inDefault;

  483.     return noErr;

  484. }

  485. 

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

  487. {

  488.     OSStatus res;

  489.     UInt32 theSize = sizeof(UInt32);

  490.     AudioDeviceID outDefault;

  491. 

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

  493.         return res;

  494.     }

  495. 

  496.     if (outDefault == 0) {

  497.         jack_error("Error : output device is 0, please select a correct one !!");

  498.         return -1;

  499.     }

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

  501.     *id = outDefault;

  502.     return noErr;

  503. }

  504. 

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

  506. {

  507.     UInt32 size = 256;

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

  509. }

  510. 

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

  512. {

  513.     OSStatus err = noErr;

  514.     UInt32	outSize;

  515.     Boolean	outWritable;

  516. 

  517.     channelCount = 0;

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

  519.     if (err == noErr) {

  520.         AudioBufferList bufferList[outSize];

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

  522.         if (err == noErr) {

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

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

  525.             }

  526.         }

  527.     }

  528.     return err;

  529. }

  530. 

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

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

  533.         fJackInputData(NULL),

  534.         fDriverOutputData(NULL),

  535.         fPluginID(0),

  536.         fState(false),

  537.         fHogged(false),

  538.         fIOUsage(1.f),

  539.         fComputationGrain(-1.f),

  540.         fClockDriftCompensate(false)

  541. {}

  542. 

  543. JackCoreAudioDriver::~JackCoreAudioDriver()

  544. {}

  545. 

  546. OSStatus JackCoreAudioDriver::DestroyAggregateDevice()

  547. {

  548.     OSStatus osErr = noErr;

  549.     AudioObjectPropertyAddress pluginAOPA;

  550.     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;

  551.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  552.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  553.     UInt32 outDataSize;

  554. 

  555.     if (fPluginID > 0) {

  556. 

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

  558.         if (osErr != noErr) {

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

  560.             printError(osErr);

  561.             return osErr;

  562.         }

  563. 

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

  565.         if (osErr != noErr) {

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

  567.             printError(osErr);

  568.             return osErr;

  569.         }

  570. 

  571.     }

  572. 

  573.     return noErr;

  574. }

  575. 

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

  577. {

  578.     OSStatus err = noErr;

  579.     AudioObjectID sub_device[32];

  580.     UInt32 outSize = sizeof(sub_device);

  581. 

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

  583.     vector<AudioDeviceID> captureDeviceIDArray;

  584. 

  585.     if (err != noErr) {

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

  587.         captureDeviceIDArray.push_back(captureDeviceID);

  588.     } else {

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

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

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

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

  593.         }

  594.     }

  595. 

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

  597.     vector<AudioDeviceID> playbackDeviceIDArray;

  598. 

  599.     if (err != noErr) {

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

  601.         playbackDeviceIDArray.push_back(playbackDeviceID);

  602.     } else {

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

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

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

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

  607.         }

  608.     }

  609. 

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

  611. }

  612. 

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

  614. {

  615.     OSStatus osErr = noErr;

  616.     UInt32 outSize;

  617.     Boolean outWritable;

  618. 

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

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

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

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

  623.     UInt32 theQualifierDataSize = sizeof(AudioObjectID);

  624.     AudioClassID inClass = kAudioSubDeviceClassID;

  625.     void* theQualifierData = &inClass;

  626.     UInt32 subDevicesNum = 0;

  627. 

  628.     //---------------------------------------------------------------------------

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

  630.     //---------------------------------------------------------------------------

  631.     UInt32 keptclockdomain = 0;

  632.     UInt32 clockdomain = 0;

  633.     outSize = sizeof(UInt32);

  634.     bool need_clock_drift_compensation = false;

  635. 

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

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

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

  639.         } else  {

  640.             // Check clock domain

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

  642.             if (osErr != 0) {

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

  644.                 printError(osErr);

  645.             } else {

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

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

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

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

  650.                     need_clock_drift_compensation = true;

  651.                 }

  652.             }

  653.         }

  654.     }

  655. 

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

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

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

  659.         } else {

  660.             // Check clock domain

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

  662.             if (osErr != 0) {

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

  664.                 printError(osErr);

  665.             } else {

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

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

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

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

  670.                     need_clock_drift_compensation = true;

  671.                 }

  672.             }

  673.         }

  674.     }

  675. 

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

  677.     if (keptclockdomain == 0) {

  678.         need_clock_drift_compensation = true;

  679.     }

  680. 

  681.     //---------------------------------------------------------------------------

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

  683.     //---------------------------------------------------------------------------

  684. 

  685.     char device_name[256];

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

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

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

  689.     }

  690. 

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

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

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

  694.     }

  695. 

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

  697.     if (osErr != noErr) {

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

  699.         printError(osErr);

  700.         return osErr;

  701.     }

  702. 

  703.     AudioValueTranslation pluginAVT;

  704. 

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

  706. 

  707.     pluginAVT.mInputData = &inBundleRef;

  708.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  709.     pluginAVT.mOutputData = &fPluginID;

  710.     pluginAVT.mOutputDataSize = sizeof(fPluginID);

  711. 

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

  713.     if (osErr != noErr) {

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

  715.         printError(osErr);

  716.         return osErr;

  717.     }

  718. 

  719.     //-------------------------------------------------

  720.     // Create a CFDictionary for our aggregate device

  721.     //-------------------------------------------------

  722. 

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

  724. 

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

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

  727. 

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

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

  730. 

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

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

  733. 

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

  735.     int value = 1;

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

  737. 

  738.     SInt32 system;

  739.     Gestalt(gestaltSystemVersion, &system);

  740. 

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

  742. 

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

  744.     if (system < 0x00001054) {

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

  746.     } else {

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

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

  749.     }

  750. 

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

  752.     CFMutableArrayRef subDevicesArrayClock = NULL;

  753. 

  754.     /*

  755.     if (fClockDriftCompensate) {

  756.         if (need_clock_drift_compensation) {

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

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

  759. 

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

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

  762.                 if (UID) {

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

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

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

  766.                     //CFRelease(UID);

  767.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  768.                 }

  769.             }

  770. 

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

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

  773.                 if (UID) {

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

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

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

  777.                     //CFRelease(UID);

  778.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  779.                 }

  780.             }

  781. 

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

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

  784.         } else {

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

  786.         }

  787.     }

  788.     */

  789. 

  790.     //-------------------------------------------------

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

  792.     //-------------------------------------------------

  793. 

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

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

  796. 

  797.     vector<CFStringRef> captureDeviceUID;

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

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

  800.         if (ref == NULL) {

  801.             return -1;

  802.         }

  803.         captureDeviceUID.push_back(ref);

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

  805.         CFArrayAppendValue(subDevicesArray, ref);

  806.    }

  807. 

  808.     vector<CFStringRef> playbackDeviceUID;

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

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

  811.         if (ref == NULL) {

  812.             return -1;

  813.         }

  814.         playbackDeviceUID.push_back(ref);

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

  816.         CFArrayAppendValue(subDevicesArray, ref);

  817.     }

  818. 

  819.     //-----------------------------------------------------------------------

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

  821.     //-----------------------------------------------------------------------

  822. 

  823.     AudioObjectPropertyAddress pluginAOPA;

  824.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  825.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  826.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  827.     UInt32 outDataSize;

  828. 

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

  830.     if (osErr != noErr) {

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

  832.         printError(osErr);

  833.         goto error;

  834.     }

  835. 

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

  837.     if (osErr != noErr) {

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

  839.         printError(osErr);

  840.         goto error;

  841.     }

  842. 

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

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

  845.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  846. 

  847.     //-------------------------

  848.     // Set the sub-device list

  849.     //-------------------------

  850. 

  851.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  852.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  853.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  854.     outDataSize = sizeof(CFMutableArrayRef);

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

  856.     if (osErr != noErr) {

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

  858.         printError(osErr);

  859.         goto error;

  860.     }

  861. 

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

  863.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  864. 

  865.     //-----------------------

  866.     // Set the master device

  867.     //-----------------------

  868. 

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

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

  871.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  872.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  873.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  874.     outDataSize = sizeof(CFStringRef);

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

  876.     if (osErr != noErr) {

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

  878.         printError(osErr);

  879.         goto error;

  880.     }

  881. 

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

  883.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  884. 

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

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

  887. 

  888.     if (fClockDriftCompensate) {

  889.         if (need_clock_drift_compensation) {

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

  891. 

  892.             // Get the property data size

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

  894.             if (osErr != noErr) {

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

  896.                 printError(osErr);

  897.             }

  898. 

  899.             //	Calculate the number of object IDs

  900.             subDevicesNum = outSize / sizeof(AudioObjectID);

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

  902.             AudioObjectID subDevices[subDevicesNum];

  903.             outSize = sizeof(subDevices);

  904. 

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

  906.             if (osErr != noErr) {

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

  908.                 printError(osErr);

  909.             }

  910. 

  911.             // Set kAudioSubDevicePropertyDriftCompensation property...

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

  913.                 UInt32 theDriftCompensationValue = 1;

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

  915.                 if (osErr != noErr) {

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

  917.                     printError(osErr);

  918.                 }

  919.             }

  920.         } else {

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

  922.         }

  923.     }

  924. 

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

  926.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  927. 

  928.     //----------

  929.     // Clean up

  930.     //----------

  931. 

  932.     // release the private AD key

  933.     CFRelease(AggregateDeviceNumberRef);

  934. 

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

  936.     CFRelease(aggDeviceDict);

  937.     CFRelease(subDevicesArray);

  938. 

  939.     if (subDevicesArrayClock) {

  940.         CFRelease(subDevicesArrayClock);

  941.     }

  942. 

  943.     // release the device UID

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

  945.         CFRelease(captureDeviceUID[i]);

  946.     }

  947. 

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

  949.         CFRelease(playbackDeviceUID[i]);

  950.     }

  951. 

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

  953.     return noErr;

  954. 

  955. error:

  956.     DestroyAggregateDevice();

  957.     return -1;

  958. }

  959. 

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

  961.                                       const char* playback_driver_uid,

  962.                                       char* capture_driver_name,

  963.                                       char* playback_driver_name,

  964.                                       jack_nframes_t samplerate)

  965. {

  966.     capture_driver_name[0] = 0;

  967.     playback_driver_name[0] = 0;

  968. 

  969.     // Duplex

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

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

  972. 

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

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

  975. 

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

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

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

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

  980.                     return -1;

  981.                 }

  982.             }

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

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

  985.                 return -1;

  986.             }

  987. 

  988.         } else {

  989. 

  990.             // Creates aggregate device

  991.             AudioDeviceID captureID, playbackID;

  992. 

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

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

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

  996.                     jack_error("Cannot open default input device");

  997.                     return -1;

  998.                 }

  999.             }

  1000. 

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

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

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

  1004.                     jack_error("Cannot open default output device");

  1005.                     return -1;

  1006.                 }

  1007.             }

  1008. 

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

  1010.                 return -1;

  1011.             }

  1012.         }

  1013. 

  1014.     // Capture only

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

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

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

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

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

  1020.                 jack_error("Cannot open default input device");

  1021.                 return -1;

  1022.             }

  1023.         }

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

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

  1026.             return -1;

  1027.         }

  1028. 

  1029.     // Playback only

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

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

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

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

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

  1035.                 jack_error("Cannot open default output device");

  1036.                 return -1;

  1037.             }

  1038.         }

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

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

  1041.             return -1;

  1042.         }

  1043. 

  1044.     // Use default driver in duplex mode

  1045.     } else {

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

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

  1048.             jack_error("Cannot open default device in duplex mode, so aggregate default input and default output");

  1049. 

  1050.             // Creates aggregate device

  1051.             AudioDeviceID captureID, playbackID;

  1052. 

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

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

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

  1056.                     jack_error("Cannot open default input device");

  1057.                     return -1;

  1058.                 }

  1059.             }

  1060. 

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

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

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

  1064.                     jack_error("Cannot open default output device");

  1065.                     return -1;

  1066.                 }

  1067.             }

  1068. 

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

  1070.                 return -1;

  1071.             }

  1072.         }

  1073.     }

  1074. 

  1075.     if (fHogged) {

  1076.         if (TakeHog()) {

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

  1078.         }

  1079.     }

  1080. 

  1081.     return 0;

  1082. }

  1083. 

  1084. /*

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

  1086. */

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

  1088. {

  1089.     OSStatus err = noErr;

  1090. 

  1091.     if (capturing) {

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

  1093.         if (err != noErr) {

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

  1095.             printError(err);

  1096.             return -1;

  1097.         } else {

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

  1099.         }

  1100.     }

  1101. 

  1102.     if (playing) {

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

  1104.         if (err != noErr) {

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

  1106.             printError(err);

  1107.             return -1;

  1108.         } else {

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

  1110.         }

  1111.     }

  1112. 

  1113.     if (inchannels > in_nChannels) {

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

  1115.         if (strict) {

  1116.             return -1;

  1117.         }

  1118.     }

  1119. 

  1120.     if (outchannels > out_nChannels) {

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

  1122.         if (strict) {

  1123.             return -1;

  1124.         }

  1125.     }

  1126. 

  1127.     if (inchannels == -1) {

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

  1129.         inchannels = in_nChannels;

  1130.     }

  1131. 

  1132.     if (outchannels == -1) {

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

  1134.         outchannels = out_nChannels;

  1135.     }

  1136. 

  1137.     return 0;

  1138. }

  1139. 

  1140. int JackCoreAudioDriver::SetupBufferSize(jack_nframes_t buffer_size)

  1141. {

  1142.     // Setting buffer size

  1143.     OSStatus err = noErr;

  1144.     UInt32 tmp_buffer_size = buffer_size;

  1145.     UInt32 outSize = sizeof(UInt32);

  1146. 

  1147.     err = AudioDeviceGetProperty(fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyBufferFrameSize, &outSize, &tmp_buffer_size);

  1148.     if (err != noErr) {

  1149.         jack_error("Cannot get buffer size %ld", buffer_size);

  1150.         printError(err);

  1151.         return -1;

  1152.     } else {

  1153.         jack_log("Current buffer size = %ld", tmp_buffer_size);

  1154.     }

  1155. 

  1156.     // If needed, set new buffer size

  1157.     if (buffer_size != tmp_buffer_size) {

  1158.         tmp_buffer_size = buffer_size;

  1159. 

  1160.         // To get BS change notification

  1161.         err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyBufferFrameSize, BSNotificationCallback, this);

  1162.         if (err != noErr) {

  1163.             jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyBufferFrameSize");

  1164.             printError(err);

  1165.             return -1;

  1166.         }

  1167. 

  1168.         // Waiting for BS change notification

  1169.         int count = 0;

  1170.         fState = false;

  1171. 

  1172.         err = AudioDeviceSetProperty(fDeviceID, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyBufferFrameSize, outSize, &tmp_buffer_size);

  1173.         if (err != noErr) {

  1174.             jack_error("Cannot set buffer size = %ld", tmp_buffer_size);

  1175.             printError(err);

  1176.             goto error;

  1177.         }

  1178. 

  1179.         while (!fState && count++ < WAIT_NOTIFICATION_COUNTER) {

  1180.             usleep(100000);

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

  1182.         }

  1183. 

  1184.         if (count >= WAIT_NOTIFICATION_COUNTER) {

  1185.             jack_error("Did not get buffer size notification...");

  1186.             goto error;

  1187.         }

  1188. 

  1189.         // Check new buffer size

  1190.         outSize =  sizeof(UInt32);

  1191.         err = AudioDeviceGetProperty(fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyBufferFrameSize, &outSize, &tmp_buffer_size);

  1192.         if (err != noErr) {

  1193.             jack_error("Cannot get current buffer size");

  1194.             printError(err);

  1195.         } else {

  1196.             jack_log("Checked buffer size = %ld", tmp_buffer_size);

  1197.         }

  1198. 

  1199.         // Remove BS change notification

  1200.         AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyBufferFrameSize, BSNotificationCallback);

  1201.     }

  1202. 

  1203.     return 0;

  1204. 

  1205. error:

  1206. 

  1207.     // Remove SR change notification

  1208.     AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyBufferFrameSize, BSNotificationCallback);

  1209.     return -1;

  1210. 

  1211. }

  1212. 

  1213. int JackCoreAudioDriver::SetupSampleRate(jack_nframes_t sample_rate)

  1214. {

  1215.     return SetupSampleRateAux(fDeviceID, sample_rate);

  1216. }

  1217. 

  1218. int JackCoreAudioDriver::SetupSampleRateAux(AudioDeviceID inDevice, jack_nframes_t sample_rate)

  1219. {

  1220.     OSStatus err = noErr;

  1221.     UInt32 outSize;

  1222.     Float64 tmp_sample_rate;

  1223. 

  1224.     // Get sample rate

  1225.     outSize =  sizeof(Float64);

  1226.     err = AudioDeviceGetProperty(inDevice, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &tmp_sample_rate);

  1227.     if (err != noErr) {

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

  1229.         printError(err);

  1230.         return -1;

  1231.     } else {

  1232.         jack_log("Current sample rate = %f", tmp_sample_rate);

  1233.     }

  1234. 

  1235.     // If needed, set new sample rate

  1236.     if (sample_rate != (jack_nframes_t)tmp_sample_rate) {

  1237.         tmp_sample_rate = (Float64)sample_rate;

  1238. 

  1239.         // To get SR change notification

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

  1241.         if (err != noErr) {

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

  1243.             printError(err);

  1244.             return -1;

  1245.         }

  1246. 

  1247.         // Waiting for SR change notification

  1248.         int count = 0;

  1249.         fState = false;

  1250. 

  1251.         err = AudioDeviceSetProperty(inDevice, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, outSize, &tmp_sample_rate);

  1252.         if (err != noErr) {

  1253.             jack_error("Cannot set sample rate = %ld", sample_rate);

  1254.             printError(err);

  1255.             goto error;

  1256.         }

  1257. 

  1258.         while (!fState && count++ < WAIT_NOTIFICATION_COUNTER) {

  1259.             usleep(100000);

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

  1261.         }

  1262. 

  1263.         if (count >= WAIT_NOTIFICATION_COUNTER) {

  1264.             jack_error("Did not get sample rate notification...");

  1265.             goto error;

  1266.         }

  1267. 

  1268.         // Check new sample rate

  1269.         outSize =  sizeof(Float64);

  1270.         err = AudioDeviceGetProperty(inDevice, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &tmp_sample_rate);

  1271.         if (err != noErr) {

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

  1273.             printError(err);

  1274.         } else {

  1275.             jack_log("Checked sample rate = %f", tmp_sample_rate);

  1276.         }

  1277. 

  1278.         // Remove SR change notification

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

  1280.     }

  1281. 

  1282.     return 0;

  1283. 

  1284. error:

  1285. 

  1286.     // Remove SR change notification

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

  1288.     return -1;

  1289. }

  1290. 

  1291. int JackCoreAudioDriver::OpenAUHAL(bool capturing,

  1292.                                    bool playing,

  1293.                                    int inchannels,

  1294.                                    int outchannels,

  1295.                                    int in_nChannels,

  1296.                                    int out_nChannels,

  1297.                                    const vector<int>& chan_in_list,

  1298.                                    const vector<int>& chan_out_list,

  1299.                                    jack_nframes_t buffer_size,

  1300.                                    jack_nframes_t sample_rate)

  1301. {

  1302.     ComponentResult err1;

  1303.     UInt32 enableIO;

  1304.     AudioStreamBasicDescription srcFormat, dstFormat;

  1305.     AudioDeviceID currAudioDeviceID;

  1306.     UInt32 size;

  1307. 

  1308.     jack_log("OpenAUHAL capturing = %d playing = %d inchannels = %d outchannels = %d in_nChannels = %d out_nChannels = %d chan_in_list = %d chan_out_list = %d",

  1309.         capturing, playing, inchannels, outchannels, in_nChannels, out_nChannels, chan_in_list.size(), chan_out_list.size());

  1310. 

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

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

  1313.         return -1;

  1314.     }

  1315. 

  1316.     // AUHAL

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

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

  1319. 

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

  1321.     if (err1 != noErr) {

  1322.         jack_error("Error calling OpenAComponent");

  1323.         printError(err1);

  1324.         goto error;

  1325.     }

  1326. 

  1327.     err1 = AudioUnitInitialize(fAUHAL);

  1328.     if (err1 != noErr) {

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

  1330.         printError(err1);

  1331.         goto error;

  1332.     }

  1333. 

  1334.     // Start I/O

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

  1336.         enableIO = 1;

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

  1338.     } else {

  1339.         enableIO = 0;

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

  1341.     }

  1342. 

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

  1344.     if (err1 != noErr) {

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

  1346.         printError(err1);

  1347.         goto error;

  1348.     }

  1349. 

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

  1351.         enableIO = 1;

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

  1353.     } else {

  1354.         enableIO = 0;

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

  1356.     }

  1357. 

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

  1359.     if (err1 != noErr) {

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

  1361.         printError(err1);

  1362.         goto error;

  1363.     }

  1364. 

  1365.     size = sizeof(AudioDeviceID);

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

  1367.     if (err1 != noErr) {

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

  1369.         printError(err1);

  1370.         goto error;

  1371.     } else {

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

  1373.     }

  1374. 

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

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

  1377.     if (err1 != noErr) {

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

  1379.         printError(err1);

  1380.         goto error;

  1381.     }

  1382. 

  1383.     // Set buffer size

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

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

  1386.         if (err1 != noErr) {

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

  1388.             printError(err1);

  1389.             goto error;

  1390.         }

  1391.     }

  1392. 

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

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

  1395.         if (err1 != noErr) {

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

  1397.             printError(err1);

  1398.             goto error;

  1399.         }

  1400.     }

  1401. 

  1402.     // Setup input channel map

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

  1404.         SInt32 chanArr[in_nChannels];

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

  1406.             chanArr[i] = -1;

  1407.         }

  1408.         // Explicit mapping

  1409.         if (chan_in_list.size() > 0) {

  1410.             for (uint i = 0; i < chan_in_list.size(); i++) {

  1411.                 int chan = chan_in_list[i];

  1412.                 if (chan < out_nChannels) {

  1413.                     // The wanted JACK input index for the 'chan' channel value

  1414.                     chanArr[chan] = i;

  1415.                     jack_info("Input channel = %d ==> JACK input port = %d", chan, i);

  1416.                 } else {

  1417.                     jack_info("Error input channel number is incorrect : %d", chan);

  1418.                     goto error;

  1419.                 }

  1420.             }

  1421.         } else {

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

  1423.                 chanArr[i] = i;

  1424.                 jack_info("Input channel = %d ==> JACK input port = %d", chanArr[i], i);

  1425.             }

  1426.         }

  1427. 

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

  1429.         if (err1 != noErr) {

  1430.             jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap for input");

  1431.             printError(err1);

  1432.             goto error;

  1433.         }

  1434.     }

  1435. 

  1436.     // Setup output channel map

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

  1438.         SInt32 chanArr[out_nChannels];

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

  1440.             chanArr[i] = -1;

  1441.         }

  1442.         // Explicit mapping

  1443.         if (chan_out_list.size() > 0) {

  1444.             for (uint i = 0; i < chan_out_list.size(); i++) {

  1445.                 int chan = chan_out_list[i];

  1446.                 if (chan < out_nChannels) {

  1447.                     // The wanted JACK output index for the 'chan' channel value

  1448.                     chanArr[chan] = i;

  1449.                     jack_info("JACK output port = %d ==> output channel = %d", i, chan);

  1450.                 } else {

  1451.                     jack_info("Error output channel number is incorrect : %d", chan);

  1452.                     goto error;

  1453.                 }

  1454.             }

  1455.         } else {

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

  1457.                 chanArr[i] = i;

  1458.                 jack_info("JACK output port = %d ==> output channel = %d", i, chanArr[i]);

  1459.             }

  1460.         }

  1461. 

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

  1463.         if (err1 != noErr) {

  1464.             jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap for output");

  1465.             printError(err1);

  1466.             goto error;

  1467.         }

  1468.     }

  1469. 

  1470.     // Setup stream converters

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

  1472. 

  1473.         size = sizeof(AudioStreamBasicDescription);

  1474.         err1 = AudioUnitGetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &srcFormat, &size);

  1475.         if (err1 != noErr) {

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

  1477.             printError(err1);

  1478.             goto error;

  1479.         }

  1480.         PrintStreamDesc(&srcFormat);

  1481. 

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

  1483.         srcFormat.mSampleRate = sample_rate;

  1484.         srcFormat.mFormatID = kAudioFormatLinearPCM;

  1485.         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1486.         srcFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1487.         srcFormat.mFramesPerPacket = 1;

  1488.         srcFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1489.         srcFormat.mChannelsPerFrame = inchannels;

  1490.         srcFormat.mBitsPerChannel = 32;

  1491.         PrintStreamDesc(&srcFormat);

  1492. 

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

  1494.         if (err1 != noErr) {

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

  1496.             printError(err1);

  1497.             goto error;

  1498.         }

  1499.     }

  1500. 

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

  1502. 

  1503.         size = sizeof(AudioStreamBasicDescription);

  1504.         err1 = AudioUnitGetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &dstFormat, &size);

  1505.         if (err1 != noErr) {

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

  1507.             printError(err1);

  1508.             goto error;

  1509.         }

  1510.         PrintStreamDesc(&dstFormat);

  1511. 

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

  1513.         dstFormat.mSampleRate = sample_rate;

  1514.         dstFormat.mFormatID = kAudioFormatLinearPCM;

  1515.         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1516.         dstFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1517.         dstFormat.mFramesPerPacket = 1;

  1518.         dstFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1519.         dstFormat.mChannelsPerFrame = outchannels;

  1520.         dstFormat.mBitsPerChannel = 32;

  1521.         PrintStreamDesc(&dstFormat);

  1522. 

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

  1524.         if (err1 != noErr) {

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

  1526.             printError(err1);

  1527.             goto error;

  1528.         }

  1529.     }

  1530. 

  1531.     // Setup callbacks

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

  1533.         AURenderCallbackStruct output;

  1534.         output.inputProc = Render;

  1535.         output.inputProcRefCon = this;

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

  1537.         if (err1 != noErr) {

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

  1539.             printError(err1);

  1540.             goto error;

  1541.         }

  1542.     } else {

  1543.         AURenderCallbackStruct output;

  1544.         output.inputProc = Render;

  1545.         output.inputProcRefCon = this;

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

  1547.         if (err1 != noErr) {

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

  1549.             printError(err1);

  1550.             goto error;

  1551.         }

  1552.     }

  1553. 

  1554.     return 0;

  1555. 

  1556. error:

  1557.     CloseAUHAL();

  1558.     return -1;

  1559. }

  1560. 

  1561. int JackCoreAudioDriver::SetupBuffers(int inchannels)

  1562. {

  1563.     // Prepare buffers

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

  1565.     fJackInputData->mNumberBuffers = inchannels;

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

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

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

  1569.     }

  1570.     return 0;

  1571. }

  1572. 

  1573. void JackCoreAudioDriver::DisposeBuffers()

  1574. {

  1575.     if (fJackInputData) {

  1576.         free(fJackInputData);

  1577.         fJackInputData = 0;

  1578.     }

  1579. }

  1580. 

  1581. void JackCoreAudioDriver::CloseAUHAL()

  1582. {

  1583.     AudioUnitUninitialize(fAUHAL);

  1584.     CloseComponent(fAUHAL);

  1585. }

  1586. 

  1587. int JackCoreAudioDriver::AddListeners()

  1588. {

  1589.     OSStatus err = noErr;

  1590. 

  1591.     // Add listeners

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

  1593.     if (err != noErr) {

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

  1595.         printError(err);

  1596.         return -1;

  1597.     }

  1598. 

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

  1600.     if (err != noErr) {

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

  1602.         printError(err);

  1603.         return -1;

  1604.     }

  1605. 

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

  1607.     if (err != noErr) {

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

  1609.         printError(err);

  1610.         return -1;

  1611.     }

  1612. 

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

  1614.     if (err != noErr) {

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

  1616.         printError(err);

  1617.         return -1;

  1618.     }

  1619. 

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

  1621.     if (err != noErr) {

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

  1623.         printError(err);

  1624.         return -1;

  1625.     }

  1626. 

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

  1628.     if (err != noErr) {

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

  1630.         printError(err);

  1631.         return -1;

  1632.     }

  1633. 

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

  1635.         UInt32 outSize = sizeof(float);

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

  1637.         if (err != noErr) {

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

  1639.             printError(err);

  1640.         }

  1641.     }

  1642. 

  1643.     return 0;

  1644. }

  1645. 

  1646. void JackCoreAudioDriver::RemoveListeners()

  1647. {

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

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

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

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

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

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

  1654. }

  1655. 

  1656. int JackCoreAudioDriver::Open(jack_nframes_t buffer_size,

  1657.                               jack_nframes_t sample_rate,

  1658.                               bool capturing,

  1659.                               bool playing,

  1660.                               int inchannels,

  1661.                               int outchannels,

  1662.                               const char* chan_in_list,

  1663.                               const char* chan_out_list,

  1664.                               bool monitor,

  1665.                               const char* capture_driver_uid,

  1666.                               const char* playback_driver_uid,

  1667.                               jack_nframes_t capture_latency,

  1668.                               jack_nframes_t playback_latency,

  1669.                               int async_output_latency,

  1670.                               int computation_grain,

  1671.                               bool hogged,

  1672.                               bool clock_drift)

  1673. {

  1674.     int in_nChannels = 0;

  1675.     int out_nChannels = 0;

  1676.     char capture_driver_name[256];

  1677.     char playback_driver_name[256];

  1678. 

  1679.     // Keep initial state

  1680.     strcpy(fCaptureUID, capture_driver_uid);

  1681.     strcpy(fPlaybackUID, playback_driver_uid);

  1682.     fCaptureLatency = capture_latency;

  1683.     fPlaybackLatency = playback_latency;

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

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

  1686.     fHogged = hogged;

  1687.     fClockDriftCompensate = clock_drift;

  1688. 

  1689.     SInt32 major;

  1690.     SInt32 minor;

  1691.     Gestalt(gestaltSystemVersionMajor, &major);

  1692.     Gestalt(gestaltSystemVersionMinor, &minor);

  1693. 

  1694.     vector<int> parsed_chan_in_list;

  1695.     vector<int> parsed_chan_out_list;

  1696. 

  1697.     ParseChannelList(chan_in_list, parsed_chan_in_list);

  1698.     if (parsed_chan_in_list.size() > 0) {

  1699.         jack_info("Explicit input channel list size = %d", parsed_chan_in_list.size());

  1700.         inchannels = parsed_chan_in_list.size();

  1701.     }

  1702. 

  1703.     ParseChannelList(chan_out_list, parsed_chan_out_list);

  1704.     if (parsed_chan_out_list.size() > 0) {

  1705.         jack_info("Explicit output channel list size = %d", parsed_chan_out_list.size());

  1706.         outchannels = parsed_chan_out_list.size();

  1707.     }

  1708. 

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

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

  1711.         CFRunLoopRef theRunLoop = NULL;

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

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

  1714.         if (osErr != noErr) {

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

  1716.             printError(osErr);

  1717.         }

  1718.     }

  1719. 

  1720.     if (SetupDevices(capture_driver_uid, playback_driver_uid, capture_driver_name, playback_driver_name, sample_rate) < 0) {

  1721.         goto error;

  1722.     }

  1723. 

  1724.     // Generic JackAudioDriver Open

  1725.     if (JackAudioDriver::Open(buffer_size, sample_rate,

  1726.                             capturing, playing,

  1727.                             inchannels, outchannels,

  1728.                             monitor,

  1729.                             capture_driver_name,

  1730.                             playback_driver_name,

  1731.                             capture_latency,

  1732.                             playback_latency) != 0) {

  1733.         goto error;

  1734.     }

  1735. 

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

  1737.         goto error;

  1738.     }

  1739. 

  1740.     if (SetupBufferSize(buffer_size) < 0) {

  1741.         goto error;

  1742.     }

  1743. 

  1744.     if (SetupSampleRate(sample_rate) < 0) {

  1745.         goto error;

  1746.     }

  1747. 

  1748.     if (OpenAUHAL(capturing, playing, inchannels, outchannels, in_nChannels, out_nChannels, parsed_chan_in_list, parsed_chan_out_list, buffer_size, sample_rate) < 0) {

  1749.         goto error;

  1750.     }

  1751. 

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

  1753.         if (SetupBuffers(inchannels) < 0) {

  1754.             goto error;

  1755.         }

  1756.     }

  1757. 

  1758.     if (AddListeners() < 0) {

  1759.         goto error;

  1760.     }

  1761. 

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

  1763.     fCaptureChannels = inchannels;

  1764.     fPlaybackChannels = outchannels;

  1765.     return noErr;

  1766. 

  1767. error:

  1768.     Close();

  1769.     return -1;

  1770. }

  1771. 

  1772. int JackCoreAudioDriver::Close()

  1773. {

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

  1775. 

  1776.     // Generic audio driver close

  1777.     int res = JackAudioDriver::Close();

  1778. 

  1779.     RemoveListeners();

  1780.     DisposeBuffers();

  1781.     CloseAUHAL();

  1782.     DestroyAggregateDevice();

  1783.     return res;

  1784. }

  1785. 

  1786. void JackCoreAudioDriver::UpdateLatencies()

  1787. {

  1788.     UInt32 size;

  1789.     OSStatus err;

  1790.     jack_latency_range_t range;

  1791.     range.max = fEngineControl->fBufferSize;

  1792.     range.min = fEngineControl->fBufferSize;

  1793. 

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

  1795.         size = sizeof(UInt32);

  1796.         UInt32 value1 = 0;

  1797.         UInt32 value2 = 0;

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

  1799.         if (err != noErr) {

  1800.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error");

  1801.         }

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

  1803.         if (err != noErr) {

  1804.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");

  1805.         }

  1806. 

  1807.         range.min = range.max = fEngineControl->fBufferSize + value1 + value2 + fCaptureLatency;

  1808.         fGraphManager->GetPort(fCapturePortList[i])->SetLatencyRange(JackCaptureLatency, &range);

  1809.     }

  1810. 

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

  1812.         size = sizeof(UInt32);

  1813.         UInt32 value1 = 0;

  1814.         UInt32 value2 = 0;

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

  1816.         if (err != noErr) {

  1817.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error");

  1818.         }

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

  1820.         if (err != noErr) {

  1821.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");

  1822.         }

  1823. 

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

  1825.         range.min = range.max

  1826.             = fEngineControl->fBufferSize + ((fEngineControl->fSyncMode) ? 0 : fEngineControl->fBufferSize * fIOUsage) + value1 + value2 + fPlaybackLatency;

  1827.         fGraphManager->GetPort(fPlaybackPortList[i])->SetLatencyRange(JackPlaybackLatency, &range);

  1828. 

  1829.         // Monitor port

  1830.         if (fWithMonitorPorts) {

  1831.             range.min = range.max = fEngineControl->fBufferSize;

  1832.             fGraphManager->GetPort(fMonitorPortList[i])->SetLatencyRange(JackCaptureLatency, &range);

  1833.         }

  1834.     }

  1835. }

  1836. 

  1837. int JackCoreAudioDriver::Attach()

  1838. {

  1839.     OSStatus err;

  1840.     JackPort* port;

  1841.     jack_port_id_t port_index;

  1842.     UInt32 size;

  1843.     Boolean isWritable;

  1844.     char channel_name[64];

  1845.     char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  1846.     char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  1847. 

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

  1849. 

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

  1851. 

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

  1853.         if (err != noErr) {

  1854.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error");

  1855.         }

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

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

  1858.             if (err != noErr) {

  1859.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error");

  1860.             }

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

  1862.         } else {

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

  1864.         }

  1865. 

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

  1867. 

  1868.         if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, CaptureDriverFlags, fEngineControl->fBufferSize, &port_index) < 0) {

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

  1870.             return -1;

  1871.         }

  1872. 

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

  1874.         port->SetAlias(alias);

  1875.         fCapturePortList[i] = port_index;

  1876.     }

  1877. 

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

  1879. 

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

  1881.         if (err != noErr) {

  1882.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error");

  1883.         }

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

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

  1886.             if (err != noErr) {

  1887.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error");

  1888.             }

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

  1890.         } else {

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

  1892.         }

  1893. 

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

  1895. 

  1896.         if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, PlaybackDriverFlags, fEngineControl->fBufferSize, &port_index) < 0) {

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

  1898.             return -1;

  1899.         }

  1900. 

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

  1902.         port->SetAlias(alias);

  1903.         fPlaybackPortList[i] = port_index;

  1904. 

  1905.         // Monitor ports

  1906.         if (fWithMonitorPorts) {

  1907.             jack_log("Create monitor port");

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

  1909.             if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, MonitorDriverFlags, fEngineControl->fBufferSize, &port_index) < 0) {

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

  1911.                 return -1;

  1912.             } else {

  1913.                 fMonitorPortList[i] = port_index;

  1914.             }

  1915.         }

  1916.     }

  1917. 

  1918.     UpdateLatencies();

  1919. 

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

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

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

  1923.     }

  1924. 

  1925.     return 0;

  1926. }

  1927. 

  1928. int JackCoreAudioDriver::Start()

  1929. {

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

  1931.     if (JackAudioDriver::Start() == 0) {

  1932. 

  1933.         // Waiting for Render callback to be called (= driver has started)

  1934.         fState = false;

  1935.         int count = 0;

  1936. 

  1937.         OSStatus err = AudioOutputUnitStart(fAUHAL);

  1938.         if (err == noErr) {

  1939. 

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

  1941.                 usleep(100000);

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

  1943.             }

  1944. 

  1945.             if (count < WAIT_COUNTER) {

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

  1947.                 return 0;

  1948.             }

  1949. 

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

  1951.         }

  1952.         JackAudioDriver::Stop();

  1953.     }

  1954.     return -1;

  1955. }

  1956. 

  1957. int JackCoreAudioDriver::Stop()

  1958. {

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

  1960.     int res = (AudioOutputUnitStop(fAUHAL) == noErr) ? 0 : -1;

  1961.     if (JackAudioDriver::Stop() < 0) {

  1962.         res = -1;

  1963.     }

  1964.     return res;

  1965. }

  1966. 

  1967. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  1968. {

  1969.     if (SetupBufferSize(buffer_size) < 0) {

  1970.         return -1;

  1971.     }

  1972. 

  1973.     JackAudioDriver::SetBufferSize(buffer_size); // Generic change, never fails

  1974. 

  1975.     // CoreAudio specific

  1976.     UpdateLatencies();

  1977. 

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

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

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

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

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

  1983.     }

  1984. 

  1985.     return 0;

  1986. }

  1987. 

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

  1989. {

  1990.     pid_t hog_pid;

  1991.     OSStatus err;

  1992. 

  1993.     UInt32 propSize = sizeof(hog_pid);

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

  1995.     if (err) {

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

  1997.         printError(err);

  1998.     }

  1999. 

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

  2001.         hog_pid = getpid();

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

  2003.         if (err != noErr) {

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

  2005.             return false;

  2006.         }

  2007.     }

  2008. 

  2009.     return true;

  2010. }

  2011. 

  2012. bool JackCoreAudioDriver::TakeHog()

  2013. {

  2014.     OSStatus err = noErr;

  2015.     AudioObjectID sub_device[32];

  2016.     UInt32 outSize = sizeof(sub_device);

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

  2018. 

  2019.     if (err != noErr) {

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

  2021.         return TakeHogAux(fDeviceID, true);

  2022.     } else {

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

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

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

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

  2027.                 return false;

  2028.             }

  2029.         }

  2030.         return true;

  2031.     }

  2032. }

  2033. 

  2034. bool JackCoreAudioDriver::IsAggregateDevice(AudioDeviceID device)

  2035. {

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

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

  2038. 

  2039.     if (err != noErr) {

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

  2041.         return false;

  2042.     } else {

  2043.         return (deviceType == kAudioDeviceTransportTypeAggregate);

  2044.     }

  2045. }

  2046. 

  2047. 

  2048. } // end of namespace

  2049. 

  2050. 

  2051. #ifdef __cplusplus

  2052. extern "C"

  2053. {

  2054. #endif

  2055. 

  2056.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor()

  2057.     {

  2058.         jack_driver_desc_t * desc;

  2059.         jack_driver_desc_filler_t filler;

  2060.         jack_driver_param_value_t value;

  2061. 

  2062.         desc = jack_driver_descriptor_construct("coreaudio", JackDriverMaster, "Apple CoreAudio API based audio backend", &filler);

  2063. 

  2064.         value.i = -1;

  2065.         jack_driver_descriptor_add_parameter(desc, &filler, "channels", 'c', JackDriverParamInt, &value, NULL, "Maximum number of channels", "Maximum number of channels. If -1, max possible number of channels will be used");

  2066.         jack_driver_descriptor_add_parameter(desc, &filler, "in-channels", 'i', JackDriverParamInt, &value, NULL, "Maximum number of input channels", "Maximum number of input channels. If -1, max possible number of input channels will be used");

  2067.         jack_driver_descriptor_add_parameter(desc, &filler, "out-channels", 'o', JackDriverParamInt, &value, NULL, "Maximum number of output channels", "Maximum number of output channels. If -1, max possible number of output channels will be used");

  2068. 

  2069.         value.str[0] = 0;

  2070.         jack_driver_descriptor_add_parameter(desc, &filler, "input-list", 'n', JackDriverParamString, &value, NULL, "Input channel list", "List of input channel number to be opened");

  2071.         jack_driver_descriptor_add_parameter(desc, &filler, "output-list", 'N', JackDriverParamString, &value, NULL, "Output channel list", "List of output channel number to be opened");

  2072. 

  2073.         value.str[0] = 0;

  2074.         jack_driver_descriptor_add_parameter(desc, &filler, "capture", 'C', JackDriverParamString, &value, NULL, "Input CoreAudio device name", NULL);

  2075.         jack_driver_descriptor_add_parameter(desc, &filler, "playback", 'P', JackDriverParamString, &value, NULL, "Output CoreAudio device name", NULL);

  2076. 

  2077.         value.i  = 0;

  2078.         jack_driver_descriptor_add_parameter(desc, &filler, "monitor", 'm', JackDriverParamBool, &value, NULL, "Provide monitor ports for the output", NULL);

  2079. 

  2080.         value.i  = TRUE;

  2081.         jack_driver_descriptor_add_parameter(desc, &filler, "duplex", 'D', JackDriverParamBool, &value, NULL, "Provide both capture and playback ports", NULL);

  2082. 

  2083.         value.ui  = 44100U;

  2084.         jack_driver_descriptor_add_parameter(desc, &filler, "rate", 'r', JackDriverParamUInt, &value, NULL, "Sample rate", NULL);

  2085. 

  2086.         value.ui  = 256U;

  2087.         jack_driver_descriptor_add_parameter(desc, &filler, "period", 'p', JackDriverParamUInt, &value, NULL, "Frames per period", NULL);

  2088. 

  2089.         value.str[0] = 0;

  2090.         jack_driver_descriptor_add_parameter(desc, &filler, "device", 'd', JackDriverParamString, &value, NULL, "CoreAudio device name", NULL);

  2091. 

  2092.         value.ui  = 0;

  2093.         jack_driver_descriptor_add_parameter(desc, &filler, "input-latency", 'I', JackDriverParamUInt, &value, NULL, "Extra input latency (frames)", NULL);

  2094.         jack_driver_descriptor_add_parameter(desc, &filler, "output-latency", 'O', JackDriverParamUInt, &value, NULL, "Extra output latency (frames)", NULL);

  2095. 

  2096.         value.i  = FALSE;

  2097.         jack_driver_descriptor_add_parameter(desc, &filler, "list-devices", 'l', JackDriverParamBool, &value, NULL, "Display available CoreAudio devices", NULL);

  2098. 

  2099.         value.i  = FALSE;

  2100.         jack_driver_descriptor_add_parameter(desc, &filler, "hog", 'H', JackDriverParamBool, &value, NULL, "Take exclusive access of the audio device", NULL);

  2101. 

  2102.         value.ui  = 100;

  2103.         jack_driver_descriptor_add_parameter(desc, &filler, "async-latency", 'L', JackDriverParamUInt, &value, NULL, "Extra output latency in asynchronous mode (percent)", NULL);

  2104. 

  2105.         value.ui  = 100;

  2106.         jack_driver_descriptor_add_parameter(desc, &filler, "grain", 'G', JackDriverParamUInt, &value, NULL, "Computation grain in RT thread (percent)", NULL);

  2107. 

  2108.         value.i = FALSE;

  2109.         jack_driver_descriptor_add_parameter(desc, &filler, "clock-drift", 's', JackDriverParamBool, &value, NULL, "Clock drift compensation", "Whether to compensate clock drift in dynamically created aggregate device");

  2110. 

  2111.         return desc;

  2112.     }

  2113. 

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

  2115.     {

  2116.         jack_nframes_t srate = 44100;

  2117.         jack_nframes_t frames_per_interrupt = 256;

  2118.         bool capture = false;

  2119.         bool playback = false;

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

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

  2122.         const char* chan_in_list = "";

  2123.         const char* chan_out_list = "";

  2124.         bool monitor = false;

  2125.         const char* capture_driver_uid = "";

  2126.         const char* playback_driver_uid = "";

  2127.         const JSList *node;

  2128.         const jack_driver_param_t *param;

  2129.         jack_nframes_t systemic_input_latency = 0;

  2130.         jack_nframes_t systemic_output_latency = 0;

  2131.         int async_output_latency = 100;

  2132.         int computation_grain = -1;

  2133.         bool hogged = false;

  2134.         bool clock_drift = false;

  2135. 

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

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

  2138. 

  2139.             switch (param->character) {

  2140. 

  2141.                 case 'd':

  2142.                     capture_driver_uid = param->value.str;

  2143.                     playback_driver_uid = param->value.str;

  2144.                     break;

  2145. 

  2146.                 case 'D':

  2147.                     capture = true;

  2148.                     playback = true;

  2149.                     break;

  2150. 

  2151.                 case 'c':

  2152.                     chan_in = chan_out = param->value.i;

  2153.                     break;

  2154. 

  2155.                 case 'i':

  2156.                     chan_in = param->value.i;

  2157.                     break;

  2158. 

  2159.                 case 'o':

  2160.                     chan_out = param->value.i;

  2161.                     break;

  2162. 

  2163.                 case 'n':

  2164.                     chan_in_list = param->value.str;

  2165.                     break;

  2166. 

  2167.                 case 'N':

  2168.                     chan_out_list = param->value.str;

  2169.                     break;

  2170. 

  2171.                 case 'C':

  2172.                     capture = true;

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

  2174.                         capture_driver_uid = param->value.str;

  2175.                     }

  2176.                     break;

  2177. 

  2178.                 case 'P':

  2179.                     playback = true;

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

  2181.                         playback_driver_uid = param->value.str;

  2182.                     }

  2183.                     break;

  2184. 

  2185.                 case 'm':

  2186.                     monitor = param->value.i;

  2187.                     break;

  2188. 

  2189.                 case 'r':

  2190.                     srate = param->value.ui;

  2191.                     break;

  2192. 

  2193.                 case 'p':

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

  2195.                     break;

  2196. 

  2197.                 case 'I':

  2198.                     systemic_input_latency = param->value.ui;

  2199.                     break;

  2200. 

  2201.                 case 'O':

  2202.                     systemic_output_latency = param->value.ui;

  2203.                     break;

  2204. 

  2205.                 case 'l':

  2206.                     Jack::DisplayDeviceNames();

  2207.                     return NULL;

  2208. 

  2209.                 case 'H':

  2210.                     hogged = true;

  2211.                     break;

  2212. 

  2213.                 case 'L':

  2214.                     async_output_latency = param->value.ui;

  2215.                     break;

  2216. 

  2217.                 case 'G':

  2218.                     computation_grain = param->value.ui;

  2219.                     break;

  2220. 

  2221.                 case 's':

  2222.                     clock_drift = true;

  2223.                     break;

  2224.             }

  2225.         }

  2226. 

  2227.         /* duplex is the default */

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

  2229.             capture = true;

  2230.             playback = true;

  2231.         }

  2232. 

  2233.         if (strcmp(chan_in_list, "") != 0 && chan_in >= 0) {

  2234.             printf("Input channel list and in channels are both specified, input channel list will take over...\n");

  2235.         }

  2236. 

  2237.          if (strcmp(chan_out_list, "") != 0 && chan_out >= 0) {

  2238.             printf("Output channel list and out channels are both specified, output channel list will take over...\n");

  2239.         }

  2240. 

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

  2242.         if (driver->Open(frames_per_interrupt,

  2243.                         srate, capture,

  2244.                         playback, chan_in,

  2245.                         chan_out, chan_in_list,

  2246.                         chan_out_list, monitor,

  2247.                         capture_driver_uid,

  2248.                         playback_driver_uid,

  2249.                         systemic_input_latency,

  2250.                         systemic_output_latency,

  2251.                         async_output_latency,

  2252.                         computation_grain,

  2253.                         hogged, clock_drift) == 0) {

  2254.             return driver;

  2255.         } else {

  2256.             delete driver;

  2257.             return NULL;

  2258.         }

  2259.     }

  2260. 

  2261. #ifdef __cplusplus

  2262. }

  2263. #endif

  2264.