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

2334 lines
90KB
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 = 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: default 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: default 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.         int stream_count = outSize / sizeof(AudioBufferList);

  521.         AudioBufferList bufferList[stream_count];

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

  523.         if (err == noErr) {

  524.             for (uint i = 0; i < bufferList->mNumberBuffers; i++) {

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

  526.                 //jack_info("GetTotalChannels stream = %d channels = %d", i, bufferList->mBuffers[i].mNumberChannels);

  527.             }

  528.         }

  529.     }

  530.     return err;

  531. }

  532. 

  533. OSStatus JackCoreAudioDriver::GetStreamLatencies(AudioDeviceID device, bool isInput, vector<int>& latencies)

  534. {

  535.     OSStatus err = noErr;

  536.     UInt32 outSize1, outSize2, outSize3;

  537.     Boolean	outWritable;

  538. 

  539.     err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreams, &outSize1, &outWritable);

  540.     if (err == noErr) {

  541.         int stream_count = outSize1 / sizeof(UInt32);

  542.         AudioStreamID streamIDs[stream_count];

  543.         AudioBufferList bufferList[stream_count];

  544.         UInt32 streamLatency;

  545.         outSize2 = sizeof(UInt32);

  546. 

  547.         err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreams, &outSize1, streamIDs);

  548.         if (err != noErr) {

  549.             jack_error("GetStreamLatencies kAudioDevicePropertyStreams err = %d", err);

  550.             return err;

  551.         }

  552. 

  553.         err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize3, &outWritable);

  554.         if (err != noErr) {

  555.             jack_error("GetStreamLatencies kAudioDevicePropertyStreamConfiguration err = %d", err);

  556.             return err;

  557.         }

  558. 

  559.         for (int i = 0; i < stream_count; i++) {

  560.             err = AudioStreamGetProperty(streamIDs[i], 0, kAudioStreamPropertyLatency, &outSize2, &streamLatency);

  561.             if (err != noErr) {

  562.                 jack_error("GetStreamLatencies kAudioStreamPropertyLatency err = %d", err);

  563.                 return err;

  564.             }

  565.             err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize3, bufferList);

  566.             if (err != noErr) {

  567.                 jack_error("GetStreamLatencies kAudioDevicePropertyStreamConfiguration err = %d", err);

  568.                 return err;

  569.             }

  570.             // Push 'channel' time the stream latency

  571.             for (uint k = 0; k < bufferList->mBuffers[i].mNumberChannels; k++) {

  572.                 latencies.push_back(streamLatency);

  573.             }

  574.         }

  575.     }

  576.     return err;

  577. }

  578. 

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

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

  581.         fJackInputData(NULL),

  582.         fDriverOutputData(NULL),

  583.         fPluginID(0),

  584.         fState(false),

  585.         fHogged(false),

  586.         fIOUsage(1.f),

  587.         fComputationGrain(-1.f),

  588.         fClockDriftCompensate(false)

  589. {}

  590. 

  591. JackCoreAudioDriver::~JackCoreAudioDriver()

  592. {}

  593. 

  594. OSStatus JackCoreAudioDriver::DestroyAggregateDevice()

  595. {

  596.     OSStatus osErr = noErr;

  597.     AudioObjectPropertyAddress pluginAOPA;

  598.     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;

  599.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  600.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  601.     UInt32 outDataSize;

  602. 

  603.     if (fPluginID > 0) {

  604. 

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

  606.         if (osErr != noErr) {

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

  608.             printError(osErr);

  609.             return osErr;

  610.         }

  611. 

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

  613.         if (osErr != noErr) {

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

  615.             printError(osErr);

  616.             return osErr;

  617.         }

  618. 

  619.     }

  620. 

  621.     return noErr;

  622. }

  623. 

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

  625. {

  626.     OSStatus err = noErr;

  627.     AudioObjectID sub_device[32];

  628.     UInt32 outSize = sizeof(sub_device);

  629. 

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

  631.     vector<AudioDeviceID> captureDeviceIDArray;

  632. 

  633.     if (err != noErr) {

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

  635.         captureDeviceIDArray.push_back(captureDeviceID);

  636.     } else {

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

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

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

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

  641.         }

  642.     }

  643. 

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

  645.     vector<AudioDeviceID> playbackDeviceIDArray;

  646. 

  647.     if (err != noErr) {

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

  649.         playbackDeviceIDArray.push_back(playbackDeviceID);

  650.     } else {

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

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

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

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

  655.         }

  656.     }

  657. 

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

  659. }

  660. 

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

  662. {

  663.     OSStatus osErr = noErr;

  664.     UInt32 outSize;

  665.     Boolean outWritable;

  666. 

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

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

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

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

  671.     UInt32 theQualifierDataSize = sizeof(AudioObjectID);

  672.     AudioClassID inClass = kAudioSubDeviceClassID;

  673.     void* theQualifierData = &inClass;

  674.     UInt32 subDevicesNum = 0;

  675. 

  676.     //---------------------------------------------------------------------------

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

  678.     //---------------------------------------------------------------------------

  679.     UInt32 keptclockdomain = 0;

  680.     UInt32 clockdomain = 0;

  681.     outSize = sizeof(UInt32);

  682.     bool need_clock_drift_compensation = false;

  683. 

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

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

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

  687.         } else  {

  688.             // Check clock domain

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

  690.             if (osErr != 0) {

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

  692.                 printError(osErr);

  693.             } else {

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

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

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

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

  698.                     need_clock_drift_compensation = true;

  699.                 }

  700.             }

  701.         }

  702.     }

  703. 

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

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

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

  707.         } else {

  708.             // Check clock domain

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

  710.             if (osErr != 0) {

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

  712.                 printError(osErr);

  713.             } else {

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

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

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

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

  718.                     need_clock_drift_compensation = true;

  719.                 }

  720.             }

  721.         }

  722.     }

  723. 

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

  725.     if (keptclockdomain == 0) {

  726.         need_clock_drift_compensation = true;

  727.     }

  728. 

  729.     //---------------------------------------------------------------------------

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

  731.     //---------------------------------------------------------------------------

  732. 

  733.     char device_name[256];

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

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

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

  737.     }

  738. 

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

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

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

  742.     }

  743. 

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

  745.     if (osErr != noErr) {

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

  747.         printError(osErr);

  748.         return osErr;

  749.     }

  750. 

  751.     AudioValueTranslation pluginAVT;

  752. 

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

  754. 

  755.     pluginAVT.mInputData = &inBundleRef;

  756.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  757.     pluginAVT.mOutputData = &fPluginID;

  758.     pluginAVT.mOutputDataSize = sizeof(fPluginID);

  759. 

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

  761.     if (osErr != noErr) {

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

  763.         printError(osErr);

  764.         return osErr;

  765.     }

  766. 

  767.     //-------------------------------------------------

  768.     // Create a CFDictionary for our aggregate device

  769.     //-------------------------------------------------

  770. 

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

  772. 

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

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

  775. 

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

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

  778. 

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

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

  781. 

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

  783.     int value = 1;

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

  785. 

  786.     SInt32 system;

  787.     Gestalt(gestaltSystemVersion, &system);

  788. 

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

  790. 

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

  792.     if (system < 0x00001054) {

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

  794.     } else {

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

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

  797.     }

  798. 

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

  800.     CFMutableArrayRef subDevicesArrayClock = NULL;

  801. 

  802.     /*

  803.     if (fClockDriftCompensate) {

  804.         if (need_clock_drift_compensation) {

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

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

  807. 

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

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

  810.                 if (UID) {

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

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

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

  814.                     //CFRelease(UID);

  815.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  816.                 }

  817.             }

  818. 

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

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

  821.                 if (UID) {

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

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

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

  825.                     //CFRelease(UID);

  826.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  827.                 }

  828.             }

  829. 

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

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

  832.         } else {

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

  834.         }

  835.     }

  836.     */

  837. 

  838.     //-------------------------------------------------

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

  840.     //-------------------------------------------------

  841. 

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

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

  844. 

  845.     vector<CFStringRef> captureDeviceUID;

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

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

  848.         if (ref == NULL) {

  849.             return -1;

  850.         }

  851.         captureDeviceUID.push_back(ref);

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

  853.         CFArrayAppendValue(subDevicesArray, ref);

  854.    }

  855. 

  856.     vector<CFStringRef> playbackDeviceUID;

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

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

  859.         if (ref == NULL) {

  860.             return -1;

  861.         }

  862.         playbackDeviceUID.push_back(ref);

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

  864.         CFArrayAppendValue(subDevicesArray, ref);

  865.     }

  866. 

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

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

  869.     //-----------------------------------------------------------------------

  870. 

  871.     AudioObjectPropertyAddress pluginAOPA;

  872.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  873.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  874.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  875.     UInt32 outDataSize;

  876. 

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

  878.     if (osErr != noErr) {

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

  880.         printError(osErr);

  881.         goto error;

  882.     }

  883. 

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

  885.     if (osErr != noErr) {

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

  887.         printError(osErr);

  888.         goto error;

  889.     }

  890. 

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

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

  893.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  894. 

  895.     //-------------------------

  896.     // Set the sub-device list

  897.     //-------------------------

  898. 

  899.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  900.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  901.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  902.     outDataSize = sizeof(CFMutableArrayRef);

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

  904.     if (osErr != noErr) {

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

  906.         printError(osErr);

  907.         goto error;

  908.     }

  909. 

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

  911.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  912. 

  913.     //-----------------------

  914.     // Set the master device

  915.     //-----------------------

  916. 

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

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

  919.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  920.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  921.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  922.     outDataSize = sizeof(CFStringRef);

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

  924.     if (osErr != noErr) {

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

  926.         printError(osErr);

  927.         goto error;

  928.     }

  929. 

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

  931.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  932. 

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

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

  935. 

  936.     if (fClockDriftCompensate) {

  937.         if (need_clock_drift_compensation) {

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

  939. 

  940.             // Get the property data size

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

  942.             if (osErr != noErr) {

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

  944.                 printError(osErr);

  945.             }

  946. 

  947.             //	Calculate the number of object IDs

  948.             subDevicesNum = outSize / sizeof(AudioObjectID);

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

  950.             AudioObjectID subDevices[subDevicesNum];

  951.             outSize = sizeof(subDevices);

  952. 

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

  954.             if (osErr != noErr) {

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

  956.                 printError(osErr);

  957.             }

  958. 

  959.             // Set kAudioSubDevicePropertyDriftCompensation property...

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

  961.                 UInt32 theDriftCompensationValue = 1;

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

  963.                 if (osErr != noErr) {

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

  965.                     printError(osErr);

  966.                 }

  967.             }

  968.         } else {

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

  970.         }

  971.     }

  972. 

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

  974.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  975. 

  976.     //----------

  977.     // Clean up

  978.     //----------

  979. 

  980.     // release the private AD key

  981.     CFRelease(AggregateDeviceNumberRef);

  982. 

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

  984.     CFRelease(aggDeviceDict);

  985.     CFRelease(subDevicesArray);

  986. 

  987.     if (subDevicesArrayClock) {

  988.         CFRelease(subDevicesArrayClock);

  989.     }

  990. 

  991.     // release the device UID

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

  993.         CFRelease(captureDeviceUID[i]);

  994.     }

  995. 

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

  997.         CFRelease(playbackDeviceUID[i]);

  998.     }

  999. 

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

  1001.     return noErr;

  1002. 

  1003. error:

  1004.     DestroyAggregateDevice();

  1005.     return -1;

  1006. }

  1007. 

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

  1009.                                       const char* playback_driver_uid,

  1010.                                       char* capture_driver_name,

  1011.                                       char* playback_driver_name,

  1012.                                       jack_nframes_t samplerate)

  1013. {

  1014.     capture_driver_name[0] = 0;

  1015.     playback_driver_name[0] = 0;

  1016. 

  1017.     // Duplex

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

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

  1020. 

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

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

  1023. 

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

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

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

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

  1028.                     return -1;

  1029.                 }

  1030.             }

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

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

  1033.                 return -1;

  1034.             }

  1035. 

  1036.         } else {

  1037. 

  1038.             // Creates aggregate device

  1039.             AudioDeviceID captureID, playbackID;

  1040. 

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

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

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

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

  1045.                     return -1;

  1046.                 }

  1047.             }

  1048. 

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

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

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

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

  1053.                     return -1;

  1054.                 }

  1055.             }

  1056. 

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

  1058.                 return -1;

  1059.             }

  1060.         }

  1061. 

  1062.     // Capture only

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

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

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

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

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

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

  1069.                 return -1;

  1070.             }

  1071.         }

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

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

  1074.             return -1;

  1075.         }

  1076. 

  1077.     // Playback only

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

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

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

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

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

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

  1084.                 return -1;

  1085.             }

  1086.         }

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

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

  1089.             return -1;

  1090.         }

  1091. 

  1092.     // Use default driver in duplex mode

  1093.     } else {

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

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

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

  1097. 

  1098.             // Creates aggregate device

  1099.             AudioDeviceID captureID, playbackID;

  1100. 

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

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

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

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

  1105.                     return -1;

  1106.                 }

  1107.             }

  1108. 

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

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

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

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

  1113.                     return -1;

  1114.                 }

  1115.             }

  1116. 

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

  1118.                 return -1;

  1119.             }

  1120.         }

  1121.     }

  1122. 

  1123.     if (fHogged) {

  1124.         if (TakeHog()) {

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

  1126.         }

  1127.     }

  1128. 

  1129.     return 0;

  1130. }

  1131. 

  1132. /*

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

  1134. */

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

  1136. {

  1137.     OSStatus err = noErr;

  1138. 

  1139.     if (capturing) {

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

  1141.         if (err != noErr) {

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

  1143.             printError(err);

  1144.             return -1;

  1145.         } else {

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

  1147.         }

  1148.     }

  1149. 

  1150.     if (playing) {

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

  1152.         if (err != noErr) {

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

  1154.             printError(err);

  1155.             return -1;

  1156.         } else {

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

  1158.         }

  1159.     }

  1160. 

  1161.     if (inchannels > in_nChannels) {

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

  1163.         if (strict) {

  1164.             return -1;

  1165.         }

  1166.     }

  1167. 

  1168.     if (outchannels > out_nChannels) {

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

  1170.         if (strict) {

  1171.             return -1;

  1172.         }

  1173.     }

  1174. 

  1175.     if (inchannels == -1) {

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

  1177.         inchannels = in_nChannels;

  1178.     }

  1179. 

  1180.     if (outchannels == -1) {

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

  1182.         outchannels = out_nChannels;

  1183.     }

  1184. 

  1185.     return 0;

  1186. }

  1187. 

  1188. int JackCoreAudioDriver::SetupBufferSize(jack_nframes_t buffer_size)

  1189. {

  1190.     // Setting buffer size

  1191.     OSStatus err = noErr;

  1192.     UInt32 tmp_buffer_size = buffer_size;

  1193.     UInt32 outSize = sizeof(UInt32);

  1194. 

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

  1196.     if (err != noErr) {

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

  1198.         printError(err);

  1199.         return -1;

  1200.     } else {

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

  1202.     }

  1203. 

  1204.     // If needed, set new buffer size

  1205.     if (buffer_size != tmp_buffer_size) {

  1206.         tmp_buffer_size = buffer_size;

  1207. 

  1208.         // To get BS change notification

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

  1210.         if (err != noErr) {

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

  1212.             printError(err);

  1213.             return -1;

  1214.         }

  1215. 

  1216.         // Waiting for BS change notification

  1217.         int count = 0;

  1218.         fState = false;

  1219. 

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

  1221.         if (err != noErr) {

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

  1223.             printError(err);

  1224.             goto error;

  1225.         }

  1226. 

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

  1228.             usleep(100000);

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

  1230.         }

  1231. 

  1232.         if (count >= WAIT_NOTIFICATION_COUNTER) {

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

  1234.             goto error;

  1235.         }

  1236. 

  1237.         // Check new buffer size

  1238.         outSize =  sizeof(UInt32);

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

  1240.         if (err != noErr) {

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

  1242.             printError(err);

  1243.         } else {

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

  1245.         }

  1246. 

  1247.         // Remove BS change notification

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

  1249.     }

  1250. 

  1251.     return 0;

  1252. 

  1253. error:

  1254. 

  1255.     // Remove SR change notification

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

  1257.     return -1;

  1258. 

  1259. }

  1260. 

  1261. int JackCoreAudioDriver::SetupSampleRate(jack_nframes_t sample_rate)

  1262. {

  1263.     return SetupSampleRateAux(fDeviceID, sample_rate);

  1264. }

  1265. 

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

  1267. {

  1268.     OSStatus err = noErr;

  1269.     UInt32 outSize;

  1270.     Float64 tmp_sample_rate;

  1271. 

  1272.     // Get sample rate

  1273.     outSize =  sizeof(Float64);

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

  1275.     if (err != noErr) {

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

  1277.         printError(err);

  1278.         return -1;

  1279.     } else {

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

  1281.     }

  1282. 

  1283.     // If needed, set new sample rate

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

  1285.         tmp_sample_rate = (Float64)sample_rate;

  1286. 

  1287.         // To get SR change notification

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

  1289.         if (err != noErr) {

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

  1291.             printError(err);

  1292.             return -1;

  1293.         }

  1294. 

  1295.         // Waiting for SR change notification

  1296.         int count = 0;

  1297.         fState = false;

  1298. 

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

  1300.         if (err != noErr) {

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

  1302.             printError(err);

  1303.             goto error;

  1304.         }

  1305. 

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

  1307.             usleep(100000);

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

  1309.         }

  1310. 

  1311.         if (count >= WAIT_NOTIFICATION_COUNTER) {

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

  1313.             goto error;

  1314.         }

  1315. 

  1316.         // Check new sample rate

  1317.         outSize =  sizeof(Float64);

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

  1319.         if (err != noErr) {

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

  1321.             printError(err);

  1322.         } else {

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

  1324.         }

  1325. 

  1326.         // Remove SR change notification

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

  1328.     }

  1329. 

  1330.     return 0;

  1331. 

  1332. error:

  1333. 

  1334.     // Remove SR change notification

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

  1336.     return -1;

  1337. }

  1338. 

  1339. int JackCoreAudioDriver::OpenAUHAL(bool capturing,

  1340.                                    bool playing,

  1341.                                    int inchannels,

  1342.                                    int outchannels,

  1343.                                    int in_nChannels,

  1344.                                    int out_nChannels,

  1345.                                    const vector<int>& chan_in_list,

  1346.                                    const vector<int>& chan_out_list,

  1347.                                    jack_nframes_t buffer_size,

  1348.                                    jack_nframes_t sample_rate)

  1349. {

  1350.     ComponentResult err1;

  1351.     UInt32 enableIO;

  1352.     AudioStreamBasicDescription srcFormat, dstFormat;

  1353.     AudioDeviceID currAudioDeviceID;

  1354.     UInt32 size;

  1355. 

  1356.     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",

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

  1358. 

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

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

  1361.         return -1;

  1362.     }

  1363. 

  1364.     // AUHAL

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

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

  1367. 

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

  1369.     if (err1 != noErr) {

  1370.         jack_error("Error calling OpenAComponent");

  1371.         printError(err1);

  1372.         goto error;

  1373.     }

  1374. 

  1375.     err1 = AudioUnitInitialize(fAUHAL);

  1376.     if (err1 != noErr) {

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

  1378.         printError(err1);

  1379.         goto error;

  1380.     }

  1381. 

  1382.     // Start I/O

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

  1384.         enableIO = 1;

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

  1386.     } else {

  1387.         enableIO = 0;

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

  1389.     }

  1390. 

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

  1392.     if (err1 != noErr) {

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

  1394.         printError(err1);

  1395.         goto error;

  1396.     }

  1397. 

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

  1399.         enableIO = 1;

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

  1401.     } else {

  1402.         enableIO = 0;

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

  1404.     }

  1405. 

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

  1407.     if (err1 != noErr) {

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

  1409.         printError(err1);

  1410.         goto error;

  1411.     }

  1412. 

  1413.     size = sizeof(AudioDeviceID);

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

  1415.     if (err1 != noErr) {

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

  1417.         printError(err1);

  1418.         goto error;

  1419.     } else {

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

  1421.     }

  1422. 

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

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

  1425.     if (err1 != noErr) {

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

  1427.         printError(err1);

  1428.         goto error;

  1429.     }

  1430. 

  1431.     // Set buffer size

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

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

  1434.         if (err1 != noErr) {

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

  1436.             printError(err1);

  1437.             goto error;

  1438.         }

  1439.     }

  1440. 

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

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

  1443.         if (err1 != noErr) {

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

  1445.             printError(err1);

  1446.             goto error;

  1447.         }

  1448.     }

  1449. 

  1450.     // Setup input channel map

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

  1452.         SInt32 chanArr[in_nChannels];

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

  1454.             chanArr[i] = -1;

  1455.         }

  1456.         // Explicit mapping

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

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

  1459.                 int chan = chan_in_list[i];

  1460.                 if (chan < out_nChannels) {

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

  1462.                     chanArr[chan] = i;

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

  1464.                 } else {

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

  1466.                     goto error;

  1467.                 }

  1468.             }

  1469.         } else {

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

  1471.                 chanArr[i] = i;

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

  1473.             }

  1474.         }

  1475. 

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

  1477.         if (err1 != noErr) {

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

  1479.             printError(err1);

  1480.             goto error;

  1481.         }

  1482.     }

  1483. 

  1484.     // Setup output channel map

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

  1486.         SInt32 chanArr[out_nChannels];

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

  1488.             chanArr[i] = -1;

  1489.         }

  1490.         // Explicit mapping

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

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

  1493.                 int chan = chan_out_list[i];

  1494.                 if (chan < out_nChannels) {

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

  1496.                     chanArr[chan] = i;

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

  1498.                 } else {

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

  1500.                     goto error;

  1501.                 }

  1502.             }

  1503.         } else {

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

  1505.                 chanArr[i] = i;

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

  1507.             }

  1508.         }

  1509. 

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

  1511.         if (err1 != noErr) {

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

  1513.             printError(err1);

  1514.             goto error;

  1515.         }

  1516.     }

  1517. 

  1518.     // Setup stream converters

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

  1520. 

  1521.         size = sizeof(AudioStreamBasicDescription);

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

  1523.         if (err1 != noErr) {

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

  1525.             printError(err1);

  1526.             goto error;

  1527.         }

  1528.         PrintStreamDesc(&srcFormat);

  1529. 

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

  1531.         srcFormat.mSampleRate = sample_rate;

  1532.         srcFormat.mFormatID = kAudioFormatLinearPCM;

  1533.         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1534.         srcFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1535.         srcFormat.mFramesPerPacket = 1;

  1536.         srcFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1537.         srcFormat.mChannelsPerFrame = inchannels;

  1538.         srcFormat.mBitsPerChannel = 32;

  1539.         PrintStreamDesc(&srcFormat);

  1540. 

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

  1542.         if (err1 != noErr) {

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

  1544.             printError(err1);

  1545.             goto error;

  1546.         }

  1547.     }

  1548. 

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

  1550. 

  1551.         size = sizeof(AudioStreamBasicDescription);

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

  1553.         if (err1 != noErr) {

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

  1555.             printError(err1);

  1556.             goto error;

  1557.         }

  1558.         PrintStreamDesc(&dstFormat);

  1559. 

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

  1561.         dstFormat.mSampleRate = sample_rate;

  1562.         dstFormat.mFormatID = kAudioFormatLinearPCM;

  1563.         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1564.         dstFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1565.         dstFormat.mFramesPerPacket = 1;

  1566.         dstFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1567.         dstFormat.mChannelsPerFrame = outchannels;

  1568.         dstFormat.mBitsPerChannel = 32;

  1569.         PrintStreamDesc(&dstFormat);

  1570. 

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

  1572.         if (err1 != noErr) {

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

  1574.             printError(err1);

  1575.             goto error;

  1576.         }

  1577.     }

  1578. 

  1579.     // Setup callbacks

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

  1581.         AURenderCallbackStruct output;

  1582.         output.inputProc = Render;

  1583.         output.inputProcRefCon = this;

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

  1585.         if (err1 != noErr) {

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

  1587.             printError(err1);

  1588.             goto error;

  1589.         }

  1590.     } else {

  1591.         AURenderCallbackStruct output;

  1592.         output.inputProc = Render;

  1593.         output.inputProcRefCon = this;

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

  1595.         if (err1 != noErr) {

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

  1597.             printError(err1);

  1598.             goto error;

  1599.         }

  1600.     }

  1601. 

  1602.     return 0;

  1603. 

  1604. error:

  1605.     CloseAUHAL();

  1606.     return -1;

  1607. }

  1608. 

  1609. int JackCoreAudioDriver::SetupBuffers(int inchannels)

  1610. {

  1611.     // Prepare buffers

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

  1613.     fJackInputData->mNumberBuffers = inchannels;

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

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

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

  1617.     }

  1618.     return 0;

  1619. }

  1620. 

  1621. void JackCoreAudioDriver::DisposeBuffers()

  1622. {

  1623.     if (fJackInputData) {

  1624.         free(fJackInputData);

  1625.         fJackInputData = 0;

  1626.     }

  1627. }

  1628. 

  1629. void JackCoreAudioDriver::CloseAUHAL()

  1630. {

  1631.     AudioUnitUninitialize(fAUHAL);

  1632.     CloseComponent(fAUHAL);

  1633. }

  1634. 

  1635. int JackCoreAudioDriver::AddListeners()

  1636. {

  1637.     OSStatus err = noErr;

  1638. 

  1639.     // Add listeners

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

  1641.     if (err != noErr) {

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

  1643.         printError(err);

  1644.         return -1;

  1645.     }

  1646. 

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

  1648.     if (err != noErr) {

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

  1650.         printError(err);

  1651.         return -1;

  1652.     }

  1653. 

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

  1655.     if (err != noErr) {

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

  1657.         printError(err);

  1658.         return -1;

  1659.     }

  1660. 

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

  1662.     if (err != noErr) {

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

  1664.         printError(err);

  1665.         return -1;

  1666.     }

  1667. 

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

  1669.     if (err != noErr) {

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

  1671.         printError(err);

  1672.         return -1;

  1673.     }

  1674. 

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

  1676.     if (err != noErr) {

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

  1678.         printError(err);

  1679.         return -1;

  1680.     }

  1681. 

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

  1683.         UInt32 outSize = sizeof(float);

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

  1685.         if (err != noErr) {

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

  1687.             printError(err);

  1688.         }

  1689.     }

  1690. 

  1691.     return 0;

  1692. }

  1693. 

  1694. void JackCoreAudioDriver::RemoveListeners()

  1695. {

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

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

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

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

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

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

  1702. }

  1703. 

  1704. int JackCoreAudioDriver::Open(jack_nframes_t buffer_size,

  1705.                               jack_nframes_t sample_rate,

  1706.                               bool capturing,

  1707.                               bool playing,

  1708.                               int inchannels,

  1709.                               int outchannels,

  1710.                               const char* chan_in_list,

  1711.                               const char* chan_out_list,

  1712.                               bool monitor,

  1713.                               const char* capture_driver_uid,

  1714.                               const char* playback_driver_uid,

  1715.                               jack_nframes_t capture_latency,

  1716.                               jack_nframes_t playback_latency,

  1717.                               int async_output_latency,

  1718.                               int computation_grain,

  1719.                               bool hogged,

  1720.                               bool clock_drift)

  1721. {

  1722.     int in_nChannels = 0;

  1723.     int out_nChannels = 0;

  1724.     char capture_driver_name[256];

  1725.     char playback_driver_name[256];

  1726. 

  1727.     // Keep initial state

  1728.     strcpy(fCaptureUID, capture_driver_uid);

  1729.     strcpy(fPlaybackUID, playback_driver_uid);

  1730.     fCaptureLatency = capture_latency;

  1731.     fPlaybackLatency = playback_latency;

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

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

  1734.     fHogged = hogged;

  1735.     fClockDriftCompensate = clock_drift;

  1736. 

  1737.     SInt32 major;

  1738.     SInt32 minor;

  1739.     Gestalt(gestaltSystemVersionMajor, &major);

  1740.     Gestalt(gestaltSystemVersionMinor, &minor);

  1741. 

  1742.     vector<int> parsed_chan_in_list;

  1743.     vector<int> parsed_chan_out_list;

  1744. 

  1745.     ParseChannelList(chan_in_list, parsed_chan_in_list);

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

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

  1748.         inchannels = parsed_chan_in_list.size();

  1749.     }

  1750. 

  1751.     ParseChannelList(chan_out_list, parsed_chan_out_list);

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

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

  1754.         outchannels = parsed_chan_out_list.size();

  1755.     }

  1756. 

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

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

  1759.         CFRunLoopRef theRunLoop = NULL;

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

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

  1762.         if (osErr != noErr) {

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

  1764.             printError(osErr);

  1765.         }

  1766.     }

  1767. 

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

  1769.         goto error;

  1770.     }

  1771. 

  1772.     // Generic JackAudioDriver Open

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

  1774.                             capturing, playing,

  1775.                             inchannels, outchannels,

  1776.                             monitor,

  1777.                             capture_driver_name,

  1778.                             playback_driver_name,

  1779.                             capture_latency,

  1780.                             playback_latency) != 0) {

  1781.         goto error;

  1782.     }

  1783. 

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

  1785.         goto error;

  1786.     }

  1787. 

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

  1789.         goto error;

  1790.     }

  1791. 

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

  1793.         goto error;

  1794.     }

  1795. 

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

  1797.         goto error;

  1798.     }

  1799. 

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

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

  1802.             goto error;

  1803.         }

  1804.     }

  1805. 

  1806.     if (AddListeners() < 0) {

  1807.         goto error;

  1808.     }

  1809. 

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

  1811.     fCaptureChannels = inchannels;

  1812.     fPlaybackChannels = outchannels;

  1813.     return noErr;

  1814. 

  1815. error:

  1816.     Close();

  1817.     return -1;

  1818. }

  1819. 

  1820. int JackCoreAudioDriver::Close()

  1821. {

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

  1823. 

  1824.     // Generic audio driver close

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

  1826. 

  1827.     RemoveListeners();

  1828.     DisposeBuffers();

  1829.     CloseAUHAL();

  1830.     DestroyAggregateDevice();

  1831.     return res;

  1832. }

  1833. 

  1834. void JackCoreAudioDriver::UpdateLatencies()

  1835. {

  1836.     UInt32 size;

  1837.     OSStatus err;

  1838.     jack_latency_range_t input_range;

  1839.     jack_latency_range_t output_range;

  1840.     jack_latency_range_t monitor_range;

  1841. 

  1842.     // Get Input latency

  1843.     size = sizeof(UInt32);

  1844.     UInt32 value1 = 0;

  1845.     UInt32 value2 = 0;

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

  1847.     if (err != noErr) {

  1848.         jack_error("AudioDeviceGetProperty kAudioDevicePropertyLatency error");

  1849.     }

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

  1851.     if (err != noErr) {

  1852.         jack_error("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");

  1853.     }

  1854. 

  1855.     input_range.min = input_range.max = fEngineControl->fBufferSize + value1 + value2 + fCaptureLatency;

  1856. 

  1857.     // Get input stream latencies

  1858.     vector<int> input_latencies;

  1859.     err = GetStreamLatencies(fDeviceID, true, input_latencies);

  1860. 

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

  1862.         if (err != noErr) {

  1863.             input_range.min += input_latencies[i];

  1864.             input_range.max += input_latencies[i];

  1865.         }

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

  1867.     }

  1868. 

  1869.     // Get Output latency

  1870.     size = sizeof(UInt32);

  1871.     value1 = 0;

  1872.     value2 = 0;

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

  1874.     if (err != noErr) {

  1875.         jack_error("AudioDeviceGetProperty kAudioDevicePropertyLatency error");

  1876.     }

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

  1878.     if (err != noErr) {

  1879.         jack_error("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");

  1880.     }

  1881. 

  1882.     // Get output stream latencies

  1883.     vector<int> output_latencies;

  1884.     err = GetStreamLatencies(fDeviceID, false, output_latencies);

  1885. 

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

  1887.     output_range.min = output_range.max = fEngineControl->fBufferSize + ((fEngineControl->fSyncMode)

  1888.         ? 0 : fEngineControl->fBufferSize * fIOUsage) + value1 + value2 + fPlaybackLatency;

  1889. 

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

  1891.         if (err != noErr) {

  1892.             output_range.min += output_latencies[i];

  1893.             output_range.max += output_latencies[i];

  1894.         }

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

  1896. 

  1897.         // Monitor port

  1898.         if (fWithMonitorPorts) {

  1899.             monitor_range.min = monitor_range.max = fEngineControl->fBufferSize;

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

  1901.         }

  1902.     }

  1903. }

  1904. 

  1905. int JackCoreAudioDriver::Attach()

  1906. {

  1907.     OSStatus err;

  1908.     JackPort* port;

  1909.     jack_port_id_t port_index;

  1910.     UInt32 size;

  1911.     Boolean isWritable;

  1912.     char channel_name[64];

  1913.     char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  1914.     char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  1915. 

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

  1917. 

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

  1919. 

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

  1921.         if (err != noErr) {

  1922.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error");

  1923.         }

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

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

  1926.             if (err != noErr) {

  1927.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error");

  1928.             }

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

  1930.         } else {

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

  1932.         }

  1933. 

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

  1935. 

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

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

  1938.             return -1;

  1939.         }

  1940. 

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

  1942.         port->SetAlias(alias);

  1943.         fCapturePortList[i] = port_index;

  1944.     }

  1945. 

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

  1947. 

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

  1949.         if (err != noErr) {

  1950.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error");

  1951.         }

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

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

  1954.             if (err != noErr) {

  1955.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error");

  1956.             }

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

  1958.         } else {

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

  1960.         }

  1961. 

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

  1963. 

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

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

  1966.             return -1;

  1967.         }

  1968. 

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

  1970.         port->SetAlias(alias);

  1971.         fPlaybackPortList[i] = port_index;

  1972. 

  1973.         // Monitor ports

  1974.         if (fWithMonitorPorts) {

  1975.             jack_log("Create monitor port");

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

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

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

  1979.                 return -1;

  1980.             } else {

  1981.                 fMonitorPortList[i] = port_index;

  1982.             }

  1983.         }

  1984.     }

  1985. 

  1986.     UpdateLatencies();

  1987. 

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

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

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

  1991.     }

  1992. 

  1993.     return 0;

  1994. }

  1995. 

  1996. int JackCoreAudioDriver::Start()

  1997. {

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

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

  2000. 

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

  2002.         fState = false;

  2003.         int count = 0;

  2004. 

  2005.         OSStatus err = AudioOutputUnitStart(fAUHAL);

  2006.         if (err == noErr) {

  2007. 

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

  2009.                 usleep(100000);

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

  2011.             }

  2012. 

  2013.             if (count < WAIT_COUNTER) {

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

  2015.                 return 0;

  2016.             }

  2017. 

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

  2019.         }

  2020.         JackAudioDriver::Stop();

  2021.     }

  2022.     return -1;

  2023. }

  2024. 

  2025. int JackCoreAudioDriver::Stop()

  2026. {

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

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

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

  2030.         res = -1;

  2031.     }

  2032.     return res;

  2033. }

  2034. 

  2035. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  2036. {

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

  2038.         return -1;

  2039.     }

  2040. 

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

  2042. 

  2043.     // CoreAudio specific

  2044.     UpdateLatencies();

  2045. 

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

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

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

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

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

  2051.     }

  2052. 

  2053.     return 0;

  2054. }

  2055. 

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

  2057. {

  2058.     pid_t hog_pid;

  2059.     OSStatus err;

  2060. 

  2061.     UInt32 propSize = sizeof(hog_pid);

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

  2063.     if (err) {

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

  2065.         printError(err);

  2066.     }

  2067. 

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

  2069.         hog_pid = getpid();

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

  2071.         if (err != noErr) {

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

  2073.             return false;

  2074.         }

  2075.     }

  2076. 

  2077.     return true;

  2078. }

  2079. 

  2080. bool JackCoreAudioDriver::TakeHog()

  2081. {

  2082.     OSStatus err = noErr;

  2083.     AudioObjectID sub_device[32];

  2084.     UInt32 outSize = sizeof(sub_device);

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

  2086. 

  2087.     if (err != noErr) {

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

  2089.         return TakeHogAux(fDeviceID, true);

  2090.     } else {

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

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

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

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

  2095.                 return false;

  2096.             }

  2097.         }

  2098.         return true;

  2099.     }

  2100. }

  2101. 

  2102. bool JackCoreAudioDriver::IsAggregateDevice(AudioDeviceID device)

  2103. {

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

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

  2106. 

  2107.     if (err != noErr) {

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

  2109.         return false;

  2110.     } else {

  2111.         return (deviceType == kAudioDeviceTransportTypeAggregate);

  2112.     }

  2113. }

  2114. 

  2115. 

  2116. } // end of namespace

  2117. 

  2118. 

  2119. #ifdef __cplusplus

  2120. extern "C"

  2121. {

  2122. #endif

  2123. 

  2124.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor()

  2125.     {

  2126.         jack_driver_desc_t * desc;

  2127.         jack_driver_desc_filler_t filler;

  2128.         jack_driver_param_value_t value;

  2129. 

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

  2131. 

  2132.         value.i = -1;

  2133.         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");

  2134.         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");

  2135.         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");

  2136. 

  2137.         value.str[0] = 0;

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

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

  2140. 

  2141.         value.str[0] = 0;

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

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

  2144. 

  2145.         value.i  = 0;

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

  2147. 

  2148.         value.i  = TRUE;

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

  2150. 

  2151.         value.ui  = 44100U;

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

  2153. 

  2154.         value.ui  = 256U;

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

  2156. 

  2157.         value.str[0] = 0;

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

  2159. 

  2160.         value.ui  = 0;

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

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

  2163. 

  2164.         value.i  = FALSE;

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

  2166. 

  2167.         value.i  = FALSE;

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

  2169. 

  2170.         value.ui  = 100;

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

  2172. 

  2173.         value.ui  = 100;

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

  2175. 

  2176.         value.i = FALSE;

  2177.         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");

  2178. 

  2179.         return desc;

  2180.     }

  2181. 

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

  2183.     {

  2184.         jack_nframes_t srate = 44100;

  2185.         jack_nframes_t frames_per_interrupt = 256;

  2186.         bool capture = false;

  2187.         bool playback = false;

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

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

  2190.         const char* chan_in_list = "";

  2191.         const char* chan_out_list = "";

  2192.         bool monitor = false;

  2193.         const char* capture_driver_uid = "";

  2194.         const char* playback_driver_uid = "";

  2195.         const JSList *node;

  2196.         const jack_driver_param_t *param;

  2197.         jack_nframes_t systemic_input_latency = 0;

  2198.         jack_nframes_t systemic_output_latency = 0;

  2199.         int async_output_latency = 100;

  2200.         int computation_grain = -1;

  2201.         bool hogged = false;

  2202.         bool clock_drift = false;

  2203. 

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

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

  2206. 

  2207.             switch (param->character) {

  2208. 

  2209.                 case 'd':

  2210.                     capture_driver_uid = param->value.str;

  2211.                     playback_driver_uid = param->value.str;

  2212.                     break;

  2213. 

  2214.                 case 'D':

  2215.                     capture = true;

  2216.                     playback = true;

  2217.                     break;

  2218. 

  2219.                 case 'c':

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

  2221.                     break;

  2222. 

  2223.                 case 'i':

  2224.                     chan_in = param->value.i;

  2225.                     break;

  2226. 

  2227.                 case 'o':

  2228.                     chan_out = param->value.i;

  2229.                     break;

  2230. 

  2231.                 case 'n':

  2232.                     chan_in_list = param->value.str;

  2233.                     break;

  2234. 

  2235.                 case 'N':

  2236.                     chan_out_list = param->value.str;

  2237.                     break;

  2238. 

  2239.                 case 'C':

  2240.                     capture = true;

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

  2242.                         capture_driver_uid = param->value.str;

  2243.                     }

  2244.                     break;

  2245. 

  2246.                 case 'P':

  2247.                     playback = true;

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

  2249.                         playback_driver_uid = param->value.str;

  2250.                     }

  2251.                     break;

  2252. 

  2253.                 case 'm':

  2254.                     monitor = param->value.i;

  2255.                     break;

  2256. 

  2257.                 case 'r':

  2258.                     srate = param->value.ui;

  2259.                     break;

  2260. 

  2261.                 case 'p':

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

  2263.                     break;

  2264. 

  2265.                 case 'I':

  2266.                     systemic_input_latency = param->value.ui;

  2267.                     break;

  2268. 

  2269.                 case 'O':

  2270.                     systemic_output_latency = param->value.ui;

  2271.                     break;

  2272. 

  2273.                 case 'l':

  2274.                     Jack::DisplayDeviceNames();

  2275.                     return NULL;

  2276. 

  2277.                 case 'H':

  2278.                     hogged = true;

  2279.                     break;

  2280. 

  2281.                 case 'L':

  2282.                     async_output_latency = param->value.ui;

  2283.                     break;

  2284. 

  2285.                 case 'G':

  2286.                     computation_grain = param->value.ui;

  2287.                     break;

  2288. 

  2289.                 case 's':

  2290.                     clock_drift = true;

  2291.                     break;

  2292.             }

  2293.         }

  2294. 

  2295.         /* duplex is the default */

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

  2297.             capture = true;

  2298.             playback = true;

  2299.         }

  2300. 

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

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

  2303.         }

  2304. 

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

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

  2307.         }

  2308. 

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

  2310.         if (driver->Open(frames_per_interrupt,

  2311.                         srate, capture,

  2312.                         playback, chan_in,

  2313.                         chan_out, chan_in_list,

  2314.                         chan_out_list, monitor,

  2315.                         capture_driver_uid,

  2316.                         playback_driver_uid,

  2317.                         systemic_input_latency,

  2318.                         systemic_output_latency,

  2319.                         async_output_latency,

  2320.                         computation_grain,

  2321.                         hogged, clock_drift) == 0) {

  2322.             return driver;

  2323.         } else {

  2324.             delete driver;

  2325.             return NULL;

  2326.         }

  2327.     }

  2328. 

  2329. #ifdef __cplusplus

  2330. }

  2331. #endif

  2332.