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

2634 lines
102KB
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 "JackLockedEngine.h"

  30. #include "JackAC3Encoder.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 bool CheckAvailableDeviceName(const char* device_name, AudioDeviceID* device_id)

  133. {

  134.     UInt32 size;

  135.     Boolean isWritable;

  136.     int i, deviceNum;

  137.     OSStatus err;

  138. 

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

  140.     if (err != noErr) {

  141.         return false;

  142.     }

  143. 

  144.     deviceNum = size / sizeof(AudioDeviceID);

  145.     AudioDeviceID devices[deviceNum];

  146. 

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

  148.     if (err != noErr) {

  149.         return false;

  150.     }

  151. 

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

  153.         char device_name_aux[256];

  154. 

  155.         size = 256;

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

  157.         if (err != noErr) {

  158.             return false;

  159.         }

  160. 

  161.         if (strcmp(device_name_aux, device_name) == 0) {

  162.             *device_id = devices[i];

  163.             return true;

  164.         }

  165. 

  166.     }

  167. 

  168.     return false;

  169. }

  170. 

  171. static bool CheckAvailableDevice(AudioDeviceID device_id)

  172. {

  173.     UInt32 size;

  174.     Boolean isWritable;

  175.     int i, deviceNum;

  176.     OSStatus err;

  177. 

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

  179.     if (err != noErr) {

  180.         return false;

  181.     }

  182. 

  183.     deviceNum = size / sizeof(AudioDeviceID);

  184.     AudioDeviceID devices[deviceNum];

  185. 

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

  187.     if (err != noErr) {

  188.         return false;

  189.     }

  190. 

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

  192.         if (device_id == devices[i]) {

  193.             return true;

  194.         }

  195. 

  196.     }

  197. 

  198.     return false;

  199. }

  200. 

  201. 

  202. static OSStatus DisplayDeviceNames()

  203. {

  204.     UInt32 size;

  205.     Boolean isWritable;

  206.     int i, deviceNum;

  207.     OSStatus err;

  208.     CFStringRef UIname;

  209. 

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

  211.     if (err != noErr) {

  212.         return err;

  213.     }

  214. 

  215.     deviceNum = size / sizeof(AudioDeviceID);

  216.     AudioDeviceID devices[deviceNum];

  217. 

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

  219.     if (err != noErr) {

  220.         return err;

  221.     }

  222. 

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

  224.         char device_name[256];

  225.         char internal_name[256];

  226. 

  227.         size = sizeof(CFStringRef);

  228.         UIname = NULL;

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

  230.         if (err == noErr) {

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

  232.         } else {

  233.             goto error;

  234.         }

  235. 

  236.         size = 256;

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

  238.         if (err != noErr) {

  239.             return err;

  240.         }

  241. 

  242.         jack_info("Device ID = \'%d\' name = \'%s\', internal name = \'%s\' (to be used as -C, -P, or -d parameter)", devices[i], device_name, internal_name);

  243.     }

  244. 

  245.     return noErr;

  246. 

  247. error:

  248.     if (UIname != NULL) {

  249.         CFRelease(UIname);

  250.     }

  251.     return err;

  252. }

  253. 

  254. static CFStringRef GetDeviceName(AudioDeviceID id)

  255. {

  256.     UInt32 size = sizeof(CFStringRef);

  257.     CFStringRef UIname;

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

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

  260. }

  261. 

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

  263. {

  264.     stringstream ss(list);

  265.     string token;

  266. 	int chan;

  267. 

  268.     while (ss >> token) {

  269.         istringstream ins;

  270.         ins.str(token);

  271.         ins >> chan;

  272.         result.push_back(chan);

  273.     }

  274. }

  275. 

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

  277.                                      AudioUnitRenderActionFlags* ioActionFlags,

  278.                                      const AudioTimeStamp* inTimeStamp,

  279.                                      UInt32 inBusNumber,

  280.                                      UInt32 inNumberFrames,

  281.                                      AudioBufferList* ioData)

  282. {

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

  284.     driver->fActionFags = ioActionFlags;

  285.     driver->fCurrentTime = inTimeStamp;

  286.     driver->fDriverOutputData = ioData;

  287. 

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

  289.     if (set_threaded_log_function()) {

  290. 

  291.         jack_log("JackCoreAudioDriver::Render : set_threaded_log_function");

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

  293. 

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

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

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

  297.         }

  298.     }

  299. 

  300.     // Signal waiting start function...

  301.     driver->fState = true;

  302. 

  303.     driver->CycleTakeBeginTime();

  304. 

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

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

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

  308.         driver->Stop();

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

  310.         return kAudioHardwareUnsupportedOperationError;

  311.     } else {

  312.         return noErr;

  313.     }

  314. }

  315. 

  316. int JackCoreAudioDriver::Read()

  317. {

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

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

  320.     } else {

  321.         return 0;

  322.     }

  323. }

  324. 

  325. int JackCoreAudioDriver::Write()

  326. {

  327.     if (fAC3Encoder) {

  328.     

  329.         // AC3 encoding and SPDIF write

  330.         jack_default_audio_sample_t* AC3_inputs[MAX_AC3_CHANNELS];

  331.         jack_default_audio_sample_t* AC3_outputs[2];

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

  333.             AC3_inputs[i] = GetOutputBuffer(i);

  334.             // If not connected, clear the buffer

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

  336.                 memset(AC3_inputs[i], 0, sizeof(jack_default_audio_sample_t) * fEngineControl->fBufferSize);

  337.             }

  338.         }

  339.         AC3_outputs[0] = (jack_default_audio_sample_t*)fDriverOutputData->mBuffers[0].mData;

  340.         AC3_outputs[1] = (jack_default_audio_sample_t*)fDriverOutputData->mBuffers[1].mData;

  341.         fAC3Encoder->Process(AC3_inputs, AC3_outputs, fEngineControl->fBufferSize);

  342.         

  343.     } else {

  344.        

  345.         // Standard write

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

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

  348.                 jack_default_audio_sample_t* buffer = GetOutputBuffer(i);

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

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

  351.                 // Monitor ports

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

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

  354.                 }

  355.             } else {

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

  357.             }

  358.         }

  359.     }

  360.     return 0;

  361. }

  362. 

  363. OSStatus JackCoreAudioDriver::SRNotificationCallback(AudioDeviceID inDevice,

  364.                                                     UInt32 inChannel,

  365.                                                     Boolean	isInput,

  366.                                                     AudioDevicePropertyID inPropertyID,

  367.                                                     void* inClientData)

  368. {

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

  370. 

  371.     switch (inPropertyID) {

  372. 

  373.         case kAudioDevicePropertyNominalSampleRate: {

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

  375.             // Check new sample rate

  376.             Float64 tmp_sample_rate;

  377.             UInt32 outSize = sizeof(Float64);

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

  379.             if (err != noErr) {

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

  381.                 printError(err);

  382.             } else {

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

  384.             }

  385.             driver->fState = true;

  386.             break;

  387.         }

  388.     }

  389. 

  390.     return noErr;

  391. }

  392. 

  393. OSStatus JackCoreAudioDriver::BSNotificationCallback(AudioDeviceID inDevice,

  394.                                                      UInt32 inChannel,

  395.                                                      Boolean isInput,

  396.                                                      AudioDevicePropertyID inPropertyID,

  397.                                                      void* inClientData)

  398. {

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

  400. 

  401.     switch (inPropertyID) {

  402. 

  403.         case kAudioDevicePropertyBufferFrameSize: {

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

  405.             // Check new buffer size

  406.             UInt32 tmp_buffer_size;

  407.             UInt32 outSize = sizeof(UInt32);

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

  409.             if (err != noErr) {

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

  411.                 printError(err);

  412.             } else {

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

  414.             }

  415.             driver->fState = true;

  416.             break;

  417.         }

  418.     }

  419. 

  420.     return noErr;

  421. }

  422. 

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

  424. OSStatus JackCoreAudioDriver::AudioHardwareNotificationCallback(AudioHardwarePropertyID inPropertyID, void* inClientData)

  425. {

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

  427. 

  428.     switch (inPropertyID) {

  429. 

  430.         case kAudioHardwarePropertyDevices: {

  431.             jack_log("JackCoreAudioDriver::AudioHardwareNotificationCallback kAudioHardwarePropertyDevices");

  432.             DisplayDeviceNames();

  433.             AudioDeviceID captureID, playbackID;

  434.             if (CheckAvailableDevice(driver->fDeviceID) ||

  435.                 (CheckAvailableDeviceName(driver->fCaptureUID, &captureID)

  436.                 && CheckAvailableDeviceName(driver->fPlaybackUID, &playbackID))) {

  437. 

  438.             }

  439.             break;

  440.         }

  441.     }

  442. 

  443.     return noErr;

  444. }

  445. 

  446. OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,

  447.                                                         UInt32 inChannel,

  448.                                                         Boolean	isInput,

  449.                                                         AudioDevicePropertyID inPropertyID,

  450.                                                         void* inClientData)

  451. {

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

  453. 

  454.     switch (inPropertyID) {

  455. 

  456.         case kAudioDevicePropertyDeviceIsRunning: {

  457.             UInt32 isrunning = 0;

  458.             UInt32 outsize = sizeof(UInt32);

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

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

  461.             }

  462.             break;

  463.         }

  464. 

  465.         case kAudioDevicePropertyDeviceIsAlive: {

  466.             UInt32 isalive = 0;

  467.             UInt32 outsize = sizeof(UInt32);

  468.             if (AudioDeviceGetProperty(driver->fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyDeviceIsAlive, &outsize, &isalive) == noErr) {

  469.                 jack_log("JackCoreAudioDriver::DeviceNotificationCallback kAudioDevicePropertyDeviceIsAlive = %d", isalive);

  470.             }

  471.             break;

  472.         }

  473. 

  474.         case kAudioDevicePropertyDeviceHasChanged: {

  475.             UInt32 hachanged = 0;

  476.             UInt32 outsize = sizeof(UInt32);

  477.             if (AudioDeviceGetProperty(driver->fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyDeviceHasChanged, &outsize, &hachanged) == noErr) {

  478.                 jack_log("JackCoreAudioDriver::DeviceNotificationCallback kAudioDevicePropertyDeviceHasChanged = %d", hachanged);

  479.             }

  480.             break;

  481.         }

  482. 

  483.         case kAudioDeviceProcessorOverload: {

  484.             jack_error("DeviceNotificationCallback kAudioDeviceProcessorOverload");

  485.             jack_time_t cur_time = GetMicroSeconds();

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

  487.             break;

  488.         }

  489. 

  490.         case kAudioDevicePropertyStreamConfiguration: {

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

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

  493.             driver->CloseAUHAL();

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

  495.             return kAudioHardwareUnsupportedOperationError;

  496.         }

  497. 

  498.         case kAudioDevicePropertyNominalSampleRate: {

  499.             Float64 sample_rate = 0;

  500.             UInt32 outsize = sizeof(Float64);

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

  502.             if (err != noErr) {

  503.                 return kAudioHardwareUnsupportedOperationError;

  504.             }

  505. 

  506.             char device_name[256];

  507.             const char* digidesign_name = "Digidesign";

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

  509. 

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

  511. 

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

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

  514. 

  515.                     jack_log("JackCoreAudioDriver::DeviceNotificationCallback Digidesign HW = %s", device_name);

  516. 

  517.                     // Set sample rate again...

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

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

  520.                     if (err != noErr) {

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

  522.                         printError(err);

  523.                     } else {

  524.                         jack_log("JackCoreAudioDriver::DeviceNotificationCallback : set sample rate = %f", sample_rate);

  525.                     }

  526. 

  527.                     // Check new sample rate again...

  528.                     outsize = sizeof(Float64);

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

  530.                     if (err != noErr) {

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

  532.                         printError(err);

  533.                     } else {

  534.                         jack_log("JackCoreAudioDriver::DeviceNotificationCallback : checked sample rate = %f", sample_rate);

  535.                     }

  536.                     return noErr;

  537. 

  538.                 } else {

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

  540.                     driver->CloseAUHAL();

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

  542.                     return kAudioHardwareUnsupportedOperationError;

  543.                 }

  544.             }

  545.         }

  546. 

  547.     }

  548.     return noErr;

  549. }

  550. 

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

  552. {

  553.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  556. 

  557.     if (inIUD == NULL) {

  558.         return kAudioHardwareUnspecifiedError;

  559.     } else {

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

  561.         CFRelease(inIUD);

  562.         jack_log("JackCoreAudioDriver::GetDeviceIDFromUID %s %ld", UID, *id);

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

  564.     }

  565. }

  566. 

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

  568. {

  569.     OSStatus res;

  570.     UInt32 theSize = sizeof(UInt32);

  571.     AudioDeviceID inDefault;

  572.     AudioDeviceID outDefault;

  573. 

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

  575.         return res;

  576.     }

  577. 

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

  579.         return res;

  580.     }

  581. 

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

  583. 

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

  585.     if (inDefault != outDefault) {

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

  587.         return kAudioHardwareBadDeviceError;

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

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

  590.         return kAudioHardwareBadDeviceError;

  591.     } else {

  592.         *id = inDefault;

  593.         return noErr;

  594.     }

  595. }

  596. 

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

  598. {

  599.     OSStatus res;

  600.     UInt32 theSize = sizeof(UInt32);

  601.     AudioDeviceID inDefault;

  602. 

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

  604.         return res;

  605.     }

  606. 

  607.     if (inDefault == 0) {

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

  609.         return -1;

  610.     }

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

  612.     *id = inDefault;

  613.     return noErr;

  614. }

  615. 

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

  617. {

  618.     OSStatus res;

  619.     UInt32 theSize = sizeof(UInt32);

  620.     AudioDeviceID outDefault;

  621. 

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

  623.         return res;

  624.     }

  625. 

  626.     if (outDefault == 0) {

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

  628.         return -1;

  629.     }

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

  631.     *id = outDefault;

  632.     return noErr;

  633. }

  634. 

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

  636. {

  637.     UInt32 size = 256;

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

  639. }

  640. 

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

  642. {

  643.     OSStatus err = noErr;

  644.     UInt32 outSize;

  645.     Boolean	outWritable;

  646. 

  647.     channelCount = 0;

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

  649.     if (err == noErr) {

  650.         int stream_count = outSize / sizeof(AudioBufferList);

  651.         AudioBufferList bufferList[stream_count];

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

  653.         if (err == noErr) {

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

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

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

  657.             }

  658.         }

  659.     }

  660.     return err;

  661. }

  662. 

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

  664. {

  665.     OSStatus err = noErr;

  666.     UInt32 outSize1, outSize2, outSize3;

  667.     Boolean	outWritable;

  668. 

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

  670.     if (err == noErr) {

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

  672.         AudioStreamID streamIDs[stream_count];

  673.         AudioBufferList bufferList[stream_count];

  674.         UInt32 streamLatency;

  675.         outSize2 = sizeof(UInt32);

  676. 

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

  678.         if (err != noErr) {

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

  680.             return err;

  681.         }

  682. 

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

  684.         if (err != noErr) {

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

  686.             return err;

  687.         }

  688. 

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

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

  691.             if (err != noErr) {

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

  693.                 return err;

  694.             }

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

  696.             if (err != noErr) {

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

  698.                 return err;

  699.             }

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

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

  702.                 latencies.push_back(streamLatency);

  703.             }

  704.         }

  705.     }

  706.     return err;

  707. }

  708. 

  709. bool JackCoreAudioDriver::IsDigitalDevice(AudioDeviceID device)

  710. {

  711.     OSStatus err = noErr;

  712.     UInt32 outSize1;

  713.     bool is_digital = false;

  714.     

  715.     /* Get a list of all the streams on this device */

  716.     AudioObjectPropertyAddress streamsAddress = { kAudioDevicePropertyStreams, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };

  717.     err = AudioObjectGetPropertyDataSize(device, &streamsAddress, 0, NULL, &outSize1);

  718.     if (err != noErr) {

  719.         jack_error("IsDigitalDevice kAudioDevicePropertyStreams err = %d", err);

  720.         return false;

  721.     }

  722.     

  723.     int stream_count = outSize1 / sizeof(AudioStreamID);

  724.     AudioStreamID streamIDs[stream_count];

  725.     

  726.     err = AudioObjectGetPropertyData(device, &streamsAddress, 0, NULL, &outSize1, streamIDs);

  727. 

  728.     if (err != noErr) {

  729.         jack_error("IsDigitalDevice kAudioDevicePropertyStreams list err = %d", err);

  730.         return false;

  731.     }

  732.     

  733.     AudioObjectPropertyAddress physicalFormatsAddress = { kAudioStreamPropertyAvailablePhysicalFormats, kAudioObjectPropertyScopeGlobal, 0 };

  734.     

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

  736.     

  737.         /* Find a stream with a cac3 stream */

  738.         int  format_num = 0;

  739. 

  740.         /* Retrieve all the stream formats supported by each output stream */

  741.         err = AudioObjectGetPropertyDataSize(streamIDs[i], &physicalFormatsAddress, 0, NULL, &outSize1);

  742.         

  743.         if (err != noErr) {

  744.             jack_error("IsDigitalDevice kAudioStreamPropertyAvailablePhysicalFormats err = %d", err);

  745.             return false;

  746.         }

  747. 

  748.         format_num = outSize1 / sizeof(AudioStreamRangedDescription);

  749.         AudioStreamRangedDescription format_list[format_num];

  750.       

  751.         err = AudioObjectGetPropertyData(streamIDs[i], &physicalFormatsAddress, 0, NULL, &outSize1, format_list);

  752.          

  753.         if (err != noErr) {

  754.             jack_error("IsDigitalDevice could not get the list of streamformats err = %d", err);

  755.             return false;

  756.         }

  757. 

  758.         /* Check if one of the supported formats is a digital format */

  759.         for (int j = 0; j < format_num; j++) {

  760.             if (format_list[j].mFormat.mFormatID == 'IAC3' ||

  761.                 format_list[j].mFormat.mFormatID == 'iac3' ||

  762.                 format_list[j].mFormat.mFormatID == kAudioFormat60958AC3 ||

  763.                 format_list[j].mFormat.mFormatID == kAudioFormatAC3 )

  764.             {

  765.                 is_digital = true;

  766.                 break;

  767.             }

  768.         }

  769.     }

  770.        

  771.     return is_digital;

  772. }

  773. 

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

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

  776.         fAC3Encoder(NULL),

  777.         fJackInputData(NULL),

  778.         fDriverOutputData(NULL),

  779.         fPluginID(0),

  780.         fState(false),

  781.         fHogged(false),

  782.         fIOUsage(1.f),

  783.         fComputationGrain(-1.f),

  784.         fClockDriftCompensate(false)

  785. {}

  786. 

  787. JackCoreAudioDriver::~JackCoreAudioDriver()

  788. {

  789.     delete fAC3Encoder;

  790. }

  791. 

  792. OSStatus JackCoreAudioDriver::DestroyAggregateDevice()

  793. {

  794.     OSStatus osErr = noErr;

  795.     AudioObjectPropertyAddress pluginAOPA;

  796.     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;

  797.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  798.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  799.     UInt32 outDataSize;

  800. 

  801.     if (fPluginID > 0) {

  802. 

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

  804.         if (osErr != noErr) {

  805.             jack_error("DestroyAggregateDevice : AudioObjectGetPropertyDataSize error");

  806.             printError(osErr);

  807.             return osErr;

  808.         }

  809. 

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

  811.         if (osErr != noErr) {

  812.             jack_error("DestroyAggregateDevice : AudioObjectGetPropertyData error");

  813.             printError(osErr);

  814.             return osErr;

  815.         }

  816. 

  817.     }

  818. 

  819.     return noErr;

  820. }

  821. 

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

  823. {

  824.     OSStatus err = noErr;

  825.     AudioObjectID sub_device[32];

  826.     UInt32 outSize = sizeof(sub_device);

  827. 

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

  829.     vector<AudioDeviceID> captureDeviceIDArray;

  830. 

  831.     if (err != noErr) {

  832.         jack_log("JackCoreAudioDriver::CreateAggregateDevice : input device does not have subdevices");

  833.         captureDeviceIDArray.push_back(captureDeviceID);

  834.     } else {

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

  836.         jack_log("JackCoreAudioDriver::CreateAggregateDevice :Input device has %d subdevices", num_devices);

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

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

  839.         }

  840.     }

  841. 

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

  843.     vector<AudioDeviceID> playbackDeviceIDArray;

  844. 

  845.     if (err != noErr) {

  846.         jack_log("JackCoreAudioDriver::CreateAggregateDevice : output device does not have subdevices");

  847.         playbackDeviceIDArray.push_back(playbackDeviceID);

  848.     } else {

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

  850.         jack_log("JackCoreAudioDriver::CreateAggregateDevice : output device has %d subdevices", num_devices);

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

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

  853.         }

  854.     }

  855. 

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

  857. }

  858. 

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

  860. {

  861.     OSStatus osErr = noErr;

  862.     UInt32 outSize;

  863.     Boolean outWritable;

  864. 

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

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

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

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

  869.     UInt32 theQualifierDataSize = sizeof(AudioObjectID);

  870.     AudioClassID inClass = kAudioSubDeviceClassID;

  871.     void* theQualifierData = &inClass;

  872.     UInt32 subDevicesNum = 0;

  873. 

  874.     //---------------------------------------------------------------------------

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

  876.     //---------------------------------------------------------------------------

  877.     UInt32 keptclockdomain = 0;

  878.     UInt32 clockdomain = 0;

  879.     outSize = sizeof(UInt32);

  880.     bool need_clock_drift_compensation = false;

  881. 

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

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

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

  885.         } else  {

  886.             // Check clock domain

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

  888.             if (osErr != 0) {

  889.                 jack_error("CreateAggregateDevice : kAudioDevicePropertyClockDomain error");

  890.                 printError(osErr);

  891.             } else {

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

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

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

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

  896.                     need_clock_drift_compensation = true;

  897.                 }

  898.             }

  899.         }

  900.     }

  901. 

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

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

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

  905.         } else {

  906.             // Check clock domain

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

  908.             if (osErr != 0) {

  909.                 jack_error("CreateAggregateDevice : kAudioDevicePropertyClockDomain error");

  910.                 printError(osErr);

  911.             } else {

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

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

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

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

  916.                     need_clock_drift_compensation = true;

  917.                 }

  918.             }

  919.         }

  920.     }

  921. 

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

  923.     if (keptclockdomain == 0) {

  924.         need_clock_drift_compensation = true;

  925.     }

  926. 

  927.     //---------------------------------------------------------------------------

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

  929.     //---------------------------------------------------------------------------

  930. 

  931.     char device_name[256];

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

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

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

  935.     }

  936. 

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

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

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

  940.     }

  941. 

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

  943.     if (osErr != noErr) {

  944.         jack_error("CreateAggregateDevice : AudioHardwareGetPropertyInfo kAudioHardwarePropertyPlugInForBundleID error");

  945.         printError(osErr);

  946.         return osErr;

  947.     }

  948. 

  949.     AudioValueTranslation pluginAVT;

  950. 

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

  952. 

  953.     pluginAVT.mInputData = &inBundleRef;

  954.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  955.     pluginAVT.mOutputData = &fPluginID;

  956.     pluginAVT.mOutputDataSize = sizeof(fPluginID);

  957. 

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

  959.     if (osErr != noErr) {

  960.         jack_error("CreateAggregateDevice : AudioHardwareGetProperty kAudioHardwarePropertyPlugInForBundleID error");

  961.         printError(osErr);

  962.         return osErr;

  963.     }

  964. 

  965.     //-------------------------------------------------

  966.     // Create a CFDictionary for our aggregate device

  967.     //-------------------------------------------------

  968. 

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

  970. 

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

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

  973. 

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

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

  976. 

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

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

  979. 

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

  981.     int value = 1;

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

  983. 

  984.     SInt32 system;

  985.     Gestalt(gestaltSystemVersion, &system);

  986. 

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

  988. 

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

  990.     if (system < 0x00001054) {

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

  992.     } else {

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

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

  995.     }

  996. 

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

  998.     CFMutableArrayRef subDevicesArrayClock = NULL;

  999. 

  1000.     /*

  1001.     if (fClockDriftCompensate) {

  1002.         if (need_clock_drift_compensation) {

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

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

  1005. 

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

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

  1008.                 if (UID) {

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

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

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

  1012.                     //CFRelease(UID);

  1013.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  1014.                 }

  1015.             }

  1016. 

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

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

  1019.                 if (UID) {

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

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

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

  1023.                     //CFRelease(UID);

  1024.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  1025.                 }

  1026.             }

  1027. 

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

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

  1030.         } else {

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

  1032.         }

  1033.     }

  1034.     */

  1035. 

  1036.     //-------------------------------------------------

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

  1038.     //-------------------------------------------------

  1039. 

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

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

  1042. 

  1043.     vector<CFStringRef> captureDeviceUID;

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

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

  1046.         if (ref == NULL) {

  1047.             return -1;

  1048.         }

  1049.         captureDeviceUID.push_back(ref);

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

  1051.         CFArrayAppendValue(subDevicesArray, ref);

  1052.    }

  1053. 

  1054.     vector<CFStringRef> playbackDeviceUID;

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

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

  1057.         if (ref == NULL) {

  1058.             return -1;

  1059.         }

  1060.         playbackDeviceUID.push_back(ref);

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

  1062.         CFArrayAppendValue(subDevicesArray, ref);

  1063.     }

  1064. 

  1065.     //-----------------------------------------------------------------------

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

  1067.     //-----------------------------------------------------------------------

  1068. 

  1069.     AudioObjectPropertyAddress pluginAOPA;

  1070.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  1071.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1072.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1073.     UInt32 outDataSize;

  1074. 

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

  1076.     if (osErr != noErr) {

  1077.         jack_error("CreateAggregateDevice : AudioObjectGetPropertyDataSize error");

  1078.         printError(osErr);

  1079.         goto error;

  1080.     }

  1081. 

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

  1083.     if (osErr != noErr) {

  1084.         jack_error("CreateAggregateDevice : AudioObjectGetPropertyData error");

  1085.         printError(osErr);

  1086.         goto error;

  1087.     }

  1088. 

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

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

  1091.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1092. 

  1093.     //-------------------------

  1094.     // Set the sub-device list

  1095.     //-------------------------

  1096. 

  1097.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  1098.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1099.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1100.     outDataSize = sizeof(CFMutableArrayRef);

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

  1102.     if (osErr != noErr) {

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

  1104.         printError(osErr);

  1105.         goto error;

  1106.     }

  1107. 

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

  1109.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1110. 

  1111.     //-----------------------

  1112.     // Set the master device

  1113.     //-----------------------

  1114. 

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

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

  1117.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  1118.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1119.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1120.     outDataSize = sizeof(CFStringRef);

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

  1122.     if (osErr != noErr) {

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

  1124.         printError(osErr);

  1125.         goto error;

  1126.     }

  1127. 

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

  1129.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1130. 

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

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

  1133. 

  1134.     if (fClockDriftCompensate) {

  1135.         if (need_clock_drift_compensation) {

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

  1137. 

  1138.             // Get the property data size

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

  1140.             if (osErr != noErr) {

  1141.                 jack_error("CreateAggregateDevice kAudioObjectPropertyOwnedObjects error");

  1142.                 printError(osErr);

  1143.             }

  1144. 

  1145.             //	Calculate the number of object IDs

  1146.             subDevicesNum = outSize / sizeof(AudioObjectID);

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

  1148.             AudioObjectID subDevices[subDevicesNum];

  1149.             outSize = sizeof(subDevices);

  1150. 

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

  1152.             if (osErr != noErr) {

  1153.                 jack_error("CreateAggregateDevice kAudioObjectPropertyOwnedObjects error");

  1154.                 printError(osErr);

  1155.             }

  1156. 

  1157.             // Set kAudioSubDevicePropertyDriftCompensation property...

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

  1159.                 UInt32 theDriftCompensationValue = 1;

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

  1161.                 if (osErr != noErr) {

  1162.                     jack_error("CreateAggregateDevice kAudioSubDevicePropertyDriftCompensation error");

  1163.                     printError(osErr);

  1164.                 }

  1165.             }

  1166.         } else {

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

  1168.         }

  1169.     }

  1170. 

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

  1172.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1173. 

  1174.     //----------

  1175.     // Clean up

  1176.     //----------

  1177. 

  1178.     // release the private AD key

  1179.     CFRelease(AggregateDeviceNumberRef);

  1180. 

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

  1182.     CFRelease(aggDeviceDict);

  1183.     CFRelease(subDevicesArray);

  1184. 

  1185.     if (subDevicesArrayClock) {

  1186.         CFRelease(subDevicesArrayClock);

  1187.     }

  1188. 

  1189.     // release the device UID

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

  1191.         CFRelease(captureDeviceUID[i]);

  1192.     }

  1193. 

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

  1195.         CFRelease(playbackDeviceUID[i]);

  1196.     }

  1197. 

  1198.     jack_log("JackCoreAudioDriver::CreateAggregateDeviceAux : new aggregate device %ld", *outAggregateDevice);

  1199.     return noErr;

  1200. 

  1201. error:

  1202.     DestroyAggregateDevice();

  1203.     return -1;

  1204. }

  1205. 

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

  1207.                                       const char* playback_driver_uid,

  1208.                                       char* capture_driver_name,

  1209.                                       char* playback_driver_name,

  1210.                                       jack_nframes_t samplerate)

  1211. {

  1212.     capture_driver_name[0] = 0;

  1213.     playback_driver_name[0] = 0;

  1214. 

  1215.     // Duplex

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

  1217.         jack_log("JackCoreAudioDriver::SetupDevices : duplex");

  1218. 

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

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

  1221. 

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

  1223.                 jack_log("JackCoreAudioDriver::SetupDevices : will take default in/out");

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

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

  1226.                     return -1;

  1227.                 }

  1228.             }

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

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

  1231.                 return -1;

  1232.             }

  1233. 

  1234.         } else {

  1235. 

  1236.             // Creates aggregate device

  1237.             AudioDeviceID captureID, playbackID;

  1238. 

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

  1240.                 jack_log("JackCoreAudioDriver::SetupDevices : will take default input");

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

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

  1243.                     return -1;

  1244.                 }

  1245.             }

  1246. 

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

  1248.                 jack_log("JackCoreAudioDriver::SetupDevices : will take default output");

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

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

  1251.                     return -1;

  1252.                 }

  1253.             }

  1254. 

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

  1256.                 return -1;

  1257.             }

  1258. 

  1259.             GetDeviceNameFromID(captureID, fCaptureUID);

  1260.             GetDeviceNameFromID(playbackID, fPlaybackUID);

  1261.          }

  1262. 

  1263.     // Capture only

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

  1265.         jack_log("JackCoreAudioDriver::SetupDevices : capture only");

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

  1267.             jack_log("JackCoreAudioDriver::SetupDevices : will take default input");

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

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

  1270.                 return -1;

  1271.             }

  1272.         }

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

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

  1275.             return -1;

  1276.         }

  1277. 

  1278.     // Playback only

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

  1280.         jack_log("JackCoreAudioDriver::SetupDevices : playback only");

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

  1282.             jack_log("JackCoreAudioDriver::SetupDevices : will take default output");

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

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

  1285.                 return -1;

  1286.             }

  1287.         }

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

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

  1290.             return -1;

  1291.         }

  1292. 

  1293.     // Use default driver in duplex mode

  1294.     } else {

  1295.         jack_log("JackCoreAudioDriver::SetupDevices : default driver");

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

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

  1298. 

  1299.             // Creates aggregate device

  1300.             AudioDeviceID captureID, playbackID;

  1301. 

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

  1303.                 jack_log("JackCoreAudioDriver::SetupDevices : will take default input");

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

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

  1306.                     return -1;

  1307.                 }

  1308.             }

  1309. 

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

  1311.                 jack_log("JackCoreAudioDriver::SetupDevices : will take default output");

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

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

  1314.                     return -1;

  1315.                 }

  1316.             }

  1317. 

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

  1319.                 return -1;

  1320.             }

  1321. 

  1322.             GetDeviceNameFromID(captureID, fCaptureUID);

  1323.             GetDeviceNameFromID(playbackID, fPlaybackUID);

  1324.         }

  1325.     }

  1326. 

  1327.     if (fHogged) {

  1328.         if (TakeHog()) {

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

  1330.         }

  1331.     }

  1332. 

  1333.     return 0;

  1334. }

  1335. 

  1336. /*

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

  1338. */

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

  1340. {

  1341.     OSStatus err = noErr;

  1342. 

  1343.     if (capturing) {

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

  1345.         if (err != noErr) {

  1346.             jack_error("SetupChannels : cannot get input channel number");

  1347.             printError(err);

  1348.             return -1;

  1349.         } else {

  1350.             jack_log("JackCoreAudioDriver::SetupChannels : max input channels : %d", in_nChannels);

  1351.         }

  1352.     }

  1353. 

  1354.     if (playing) {

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

  1356.         if (err != noErr) {

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

  1358.             printError(err);

  1359.             return -1;

  1360.         } else {

  1361.             jack_log("JackCoreAudioDriver::SetupChannels : max output channels : %d", out_nChannels);

  1362.         }

  1363.     }

  1364. 

  1365.     if (inchannels > in_nChannels) {

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

  1367.         if (strict) {

  1368.             return -1;

  1369.         }

  1370.     }

  1371. 

  1372.     if (outchannels > out_nChannels) {

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

  1374.         if (strict) {

  1375.             return -1;

  1376.         }

  1377.     }

  1378. 

  1379.     if (inchannels == -1) {

  1380.         jack_log("JackCoreAudioDriver::SetupChannels : setup max in channels = %d", in_nChannels);

  1381.         inchannels = in_nChannels;

  1382.     }

  1383. 

  1384.     if (outchannels == -1) {

  1385.         jack_log("JackCoreAudioDriver::SetupChannels : setup max out channels = %d", out_nChannels);

  1386.         outchannels = out_nChannels;

  1387.     }

  1388. 

  1389.     return 0;

  1390. }

  1391. 

  1392. int JackCoreAudioDriver::SetupBufferSize(jack_nframes_t buffer_size)

  1393. {

  1394.     // Setting buffer size

  1395.     OSStatus err = noErr;

  1396.     UInt32 tmp_buffer_size = buffer_size;

  1397.     UInt32 outSize = sizeof(UInt32);

  1398. 

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

  1400.     if (err != noErr) {

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

  1402.         printError(err);

  1403.         return -1;

  1404.     } else {

  1405.         jack_log("JackCoreAudioDriver::SetupBufferSize : current buffer size = %ld", tmp_buffer_size);

  1406.     }

  1407. 

  1408.     // If needed, set new buffer size

  1409.     if (buffer_size != tmp_buffer_size) {

  1410.         tmp_buffer_size = buffer_size;

  1411. 

  1412.         // To get BS change notification

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

  1414.         if (err != noErr) {

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

  1416.             printError(err);

  1417.             return -1;

  1418.         }

  1419. 

  1420.         // Waiting for BS change notification

  1421.         int count = 0;

  1422.         fState = false;

  1423. 

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

  1425.         if (err != noErr) {

  1426.             jack_error("SetupBufferSize : cannot set buffer size = %ld", tmp_buffer_size);

  1427.             printError(err);

  1428.             goto error;

  1429.         }

  1430. 

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

  1432.             usleep(100000);

  1433.             jack_log("JackCoreAudioDriver::SetupBufferSize : wait count = %d", count);

  1434.         }

  1435. 

  1436.         if (count >= WAIT_NOTIFICATION_COUNTER) {

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

  1438.             goto error;

  1439.         }

  1440. 

  1441.         // Check new buffer size

  1442.         outSize = sizeof(UInt32);

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

  1444.         if (err != noErr) {

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

  1446.             printError(err);

  1447.         } else {

  1448.             jack_log("JackCoreAudioDriver::SetupBufferSize : checked buffer size = %ld", tmp_buffer_size);

  1449.         }

  1450. 

  1451.         // Remove BS change notification

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

  1453.     }

  1454. 

  1455.     return 0;

  1456. 

  1457. error:

  1458. 

  1459.     // Remove BS change notification

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

  1461.     return -1;

  1462. 

  1463. }

  1464. 

  1465. int JackCoreAudioDriver::SetupSampleRate(jack_nframes_t sample_rate)

  1466. {

  1467.     return SetupSampleRateAux(fDeviceID, sample_rate);

  1468. }

  1469. 

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

  1471. {

  1472.     OSStatus err = noErr;

  1473.     UInt32 outSize;

  1474.     Float64 tmp_sample_rate;

  1475. 

  1476.     // Get sample rate

  1477.     outSize =  sizeof(Float64);

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

  1479.     if (err != noErr) {

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

  1481.         printError(err);

  1482.         return -1;

  1483.     } else {

  1484.         jack_log("JackCoreAudioDriver::SetupSampleRateAux : current sample rate = %f", tmp_sample_rate);

  1485.     }

  1486. 

  1487.     // If needed, set new sample rate

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

  1489.         tmp_sample_rate = (Float64)sample_rate;

  1490. 

  1491.         // To get SR change notification

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

  1493.         if (err != noErr) {

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

  1495.             printError(err);

  1496.             return -1;

  1497.         }

  1498. 

  1499.         // Waiting for SR change notification

  1500.         int count = 0;

  1501.         fState = false;

  1502. 

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

  1504.         if (err != noErr) {

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

  1506.             printError(err);

  1507.             goto error;

  1508.         }

  1509. 

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

  1511.             usleep(100000);

  1512.             jack_log("JackCoreAudioDriver::SetupSampleRateAux : wait count = %d", count);

  1513.         }

  1514. 

  1515.         if (count >= WAIT_NOTIFICATION_COUNTER) {

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

  1517.             goto error;

  1518.         }

  1519. 

  1520.         // Check new sample rate

  1521.         outSize = sizeof(Float64);

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

  1523.         if (err != noErr) {

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

  1525.             printError(err);

  1526.         } else {

  1527.             jack_log("JackCoreAudioDriver::SetupSampleRateAux : checked sample rate = %f", tmp_sample_rate);

  1528.         }

  1529. 

  1530.         // Remove SR change notification

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

  1532.     }

  1533. 

  1534.     return 0;

  1535. 

  1536. error:

  1537. 

  1538.     // Remove SR change notification

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

  1540.     return -1;

  1541. }

  1542. 

  1543. int JackCoreAudioDriver::OpenAUHAL(bool capturing,

  1544.                                    bool playing,

  1545.                                    int inchannels,

  1546.                                    int outchannels,

  1547.                                    int in_nChannels,

  1548.                                    int out_nChannels,

  1549.                                    const vector<int>& chan_in_list,

  1550.                                    const vector<int>& chan_out_list,

  1551.                                    jack_nframes_t buffer_size,

  1552.                                    jack_nframes_t sample_rate)

  1553. {

  1554.     ComponentResult err1;

  1555.     UInt32 enableIO;

  1556.     AudioStreamBasicDescription srcFormat, dstFormat;

  1557.     AudioDeviceID currAudioDeviceID;

  1558.     UInt32 size;

  1559. 

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

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

  1562. 

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

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

  1565.         return -1;

  1566.     }

  1567. 

  1568.     // AUHAL

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

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

  1571. 

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

  1573.     if (err1 != noErr) {

  1574.         jack_error("Error calling OpenAComponent");

  1575.         printError(err1);

  1576.         goto error;

  1577.     }

  1578. 

  1579.     err1 = AudioUnitInitialize(fAUHAL);

  1580.     if (err1 != noErr) {

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

  1582.         printError(err1);

  1583.         goto error;

  1584.     }

  1585. 

  1586.     // Start I/O

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

  1588.         enableIO = 1;

  1589.         jack_log("JackCoreAudioDriver::OpenAUHAL : setup AUHAL input on");

  1590.     } else {

  1591.         enableIO = 0;

  1592.         jack_log("JackCoreAudioDriver::OpenAUHAL : setup AUHAL input off");

  1593.     }

  1594. 

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

  1596.     if (err1 != noErr) {

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

  1598.         printError(err1);

  1599.         goto error;

  1600.     }

  1601. 

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

  1603.         enableIO = 1;

  1604.         jack_log("JackCoreAudioDriver::OpenAUHAL : setup AUHAL output on");

  1605.     } else {

  1606.         enableIO = 0;

  1607.         jack_log("JackCoreAudioDriver::OpenAUHAL : setup AUHAL output off");

  1608.     }

  1609. 

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

  1611.     if (err1 != noErr) {

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

  1613.         printError(err1);

  1614.         goto error;

  1615.     }

  1616. 

  1617.     size = sizeof(AudioDeviceID);

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

  1619.     if (err1 != noErr) {

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

  1621.         printError(err1);

  1622.         goto error;

  1623.     } else {

  1624.         jack_log("JackCoreAudioDriver::OpenAUHAL : AudioUnitGetPropertyCurrentDevice = %d", currAudioDeviceID);

  1625.     }

  1626. 

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

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

  1629.     if (err1 != noErr) {

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

  1631.         printError(err1);

  1632.         goto error;

  1633.     }

  1634. 

  1635.     // Set buffer size

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

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

  1638.         if (err1 != noErr) {

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

  1640.             printError(err1);

  1641.             goto error;

  1642.         }

  1643.     }

  1644. 

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

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

  1647.         if (err1 != noErr) {

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

  1649.             printError(err1);

  1650.             goto error;

  1651.         }

  1652.     }

  1653. 

  1654.     // Setup input channel map

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

  1656.         SInt32 chanArr[in_nChannels];

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

  1658.             chanArr[i] = -1;

  1659.         }

  1660.         // Explicit mapping

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

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

  1663.                 int chan = chan_in_list[i];

  1664.                 if (chan < out_nChannels) {

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

  1666.                     chanArr[chan] = i;

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

  1668.                 } else {

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

  1670.                     goto error;

  1671.                 }

  1672.             }

  1673.         } else {

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

  1675.                 chanArr[i] = i;

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

  1677.             }

  1678.         }

  1679. 

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

  1681.         if (err1 != noErr) {

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

  1683.             printError(err1);

  1684.             goto error;

  1685.         }

  1686.     }

  1687. 

  1688.     // Setup output channel map

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

  1690.         SInt32 chanArr[out_nChannels];

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

  1692.             chanArr[i] = -1;

  1693.         }

  1694.         // Explicit mapping

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

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

  1697.                 int chan = chan_out_list[i];

  1698.                 if (chan < out_nChannels) {

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

  1700.                     chanArr[chan] = i;

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

  1702.                 } else {

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

  1704.                     goto error;

  1705.                 }

  1706.             }

  1707.         } else {

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

  1709.                 chanArr[i] = i;

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

  1711.             }

  1712.         }

  1713. 

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

  1715.         if (err1 != noErr) {

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

  1717.             printError(err1);

  1718.             goto error;

  1719.         }

  1720.     }

  1721. 

  1722.     // Setup stream converters

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

  1724. 

  1725.         size = sizeof(AudioStreamBasicDescription);

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

  1727.         if (err1 != noErr) {

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

  1729.             printError(err1);

  1730.             goto error;

  1731.         }

  1732.         PrintStreamDesc(&srcFormat);

  1733. 

  1734.         jack_log("JackCoreAudioDriver::OpenAUHAL : setup AUHAL input stream converter SR = %ld", sample_rate);

  1735.         srcFormat.mSampleRate = sample_rate;

  1736.         srcFormat.mFormatID = kAudioFormatLinearPCM;

  1737.         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1738.         srcFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1739.         srcFormat.mFramesPerPacket = 1;

  1740.         srcFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1741.         srcFormat.mChannelsPerFrame = inchannels;

  1742.         srcFormat.mBitsPerChannel = 32;

  1743.         PrintStreamDesc(&srcFormat);

  1744. 

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

  1746.         if (err1 != noErr) {

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

  1748.             printError(err1);

  1749.             goto error;

  1750.         }

  1751.     }

  1752. 

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

  1754. 

  1755.         size = sizeof(AudioStreamBasicDescription);

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

  1757.         if (err1 != noErr) {

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

  1759.             printError(err1);

  1760.             goto error;

  1761.         }

  1762.         PrintStreamDesc(&dstFormat);

  1763. 

  1764.         jack_log("JackCoreAudioDriver::OpenAUHAL : setup AUHAL output stream converter SR = %ld", sample_rate);

  1765.         dstFormat.mSampleRate = sample_rate;

  1766.         dstFormat.mFormatID = kAudioFormatLinearPCM;

  1767.         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1768.         dstFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1769.         dstFormat.mFramesPerPacket = 1;

  1770.         dstFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1771.         dstFormat.mChannelsPerFrame = outchannels;

  1772.         dstFormat.mBitsPerChannel = 32;

  1773.         PrintStreamDesc(&dstFormat);

  1774. 

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

  1776.         if (err1 != noErr) {

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

  1778.             printError(err1);

  1779.             goto error;

  1780.         }

  1781.     }

  1782. 

  1783.     // Setup callbacks

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

  1785.         AURenderCallbackStruct output;

  1786.         output.inputProc = Render;

  1787.         output.inputProcRefCon = this;

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

  1789.         if (err1 != noErr) {

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

  1791.             printError(err1);

  1792.             goto error;

  1793.         }

  1794.     } else {

  1795.         AURenderCallbackStruct output;

  1796.         output.inputProc = Render;

  1797.         output.inputProcRefCon = this;

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

  1799.         if (err1 != noErr) {

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

  1801.             printError(err1);

  1802.             goto error;

  1803.         }

  1804.     }

  1805. 

  1806.     return 0;

  1807. 

  1808. error:

  1809.     CloseAUHAL();

  1810.     return -1;

  1811. }

  1812. 

  1813. int JackCoreAudioDriver::SetupBuffers(int inchannels)

  1814. {

  1815.     // Prepare buffers

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

  1817.     fJackInputData->mNumberBuffers = inchannels;

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

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

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

  1821.     }

  1822.     return 0;

  1823. }

  1824. 

  1825. void JackCoreAudioDriver::DisposeBuffers()

  1826. {

  1827.     if (fJackInputData) {

  1828.         free(fJackInputData);

  1829.         fJackInputData = 0;

  1830.     }

  1831. }

  1832. 

  1833. void JackCoreAudioDriver::CloseAUHAL()

  1834. {

  1835.     AudioOutputUnitStop(fAUHAL);

  1836.     AudioUnitUninitialize(fAUHAL);

  1837.     CloseComponent(fAUHAL);

  1838. }

  1839. 

  1840. int JackCoreAudioDriver::AddListeners()

  1841. {

  1842.     OSStatus err = noErr;

  1843. 

  1844.     // Add listeners

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

  1846.     if (err != noErr) {

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

  1848.         printError(err);

  1849.         return -1;

  1850.     }

  1851. 

  1852.     err = AudioHardwareAddPropertyListener(kAudioHardwarePropertyDevices, AudioHardwareNotificationCallback, this);

  1853.     if (err != noErr) {

  1854.         jack_error("Error calling AudioHardwareAddPropertyListener with kAudioHardwarePropertyDevices");

  1855.         printError(err);

  1856.         return -1;

  1857.     }

  1858. 

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

  1860.     if (err != noErr) {

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

  1862.         printError(err);

  1863.         return -1;

  1864.     }

  1865. 

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

  1867.     if (err != noErr) {

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

  1869.         printError(err);

  1870.         return -1;

  1871.     }

  1872. 

  1873.     err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyDeviceIsAlive, DeviceNotificationCallback, this);

  1874.     if (err != noErr) {

  1875.         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyDeviceIsAlive");

  1876.         printError(err);

  1877.         return -1;

  1878.     }

  1879. 

  1880.     err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyDeviceHasChanged, DeviceNotificationCallback, this);

  1881.     if (err != noErr) {

  1882.         jack_error("Error calling AudioDeviceAddPropertyListener with kAudioDevicePropertyDeviceHasChanged");

  1883.         printError(err);

  1884.         return -1;

  1885.     }

  1886. 

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

  1888.     if (err != noErr) {

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

  1890.         printError(err);

  1891.         return -1;

  1892.     }

  1893. 

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

  1895.     if (err != noErr) {

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

  1897.         printError(err);

  1898.         return -1;

  1899.     }

  1900. 

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

  1902.         UInt32 outSize = sizeof(float);

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

  1904.         if (err != noErr) {

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

  1906.             printError(err);

  1907.         }

  1908.     }

  1909. 

  1910.     return 0;

  1911. }

  1912. 

  1913. void JackCoreAudioDriver::RemoveListeners()

  1914. {

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

  1916.     AudioHardwareRemovePropertyListener(kAudioHardwarePropertyDevices, AudioHardwareNotificationCallback);

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

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

  1919.     AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyDeviceIsAlive, DeviceNotificationCallback);

  1920.     AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyDeviceHasChanged, DeviceNotificationCallback);

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

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

  1923. }

  1924. 

  1925. int JackCoreAudioDriver::Open(jack_nframes_t buffer_size,

  1926.                               jack_nframes_t sample_rate,

  1927.                               bool capturing,

  1928.                               bool playing,

  1929.                               int inchannels,

  1930.                               int outchannels,

  1931.                               const char* chan_in_list,

  1932.                               const char* chan_out_list,

  1933.                               bool monitor,

  1934.                               const char* capture_driver_uid,

  1935.                               const char* playback_driver_uid,

  1936.                               jack_nframes_t capture_latency,

  1937.                               jack_nframes_t playback_latency,

  1938.                               int async_output_latency,

  1939.                               int computation_grain,

  1940.                               bool hogged,

  1941.                               bool clock_drift,

  1942.                               bool ac3_encoding,

  1943.                               int ac3_bitrate,

  1944.                               bool ac3_lfe)

  1945. {

  1946.     int in_nChannels = 0;

  1947.     int out_nChannels = 0;

  1948.     char capture_driver_name[256];

  1949.     char playback_driver_name[256];

  1950. 

  1951.     fCaptureLatency = capture_latency;

  1952.     fPlaybackLatency = playback_latency;

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

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

  1955.     fHogged = hogged;

  1956.     fClockDriftCompensate = clock_drift;

  1957. 

  1958.     SInt32 major;

  1959.     SInt32 minor;

  1960.     Gestalt(gestaltSystemVersionMajor, &major);

  1961.     Gestalt(gestaltSystemVersionMinor, &minor);

  1962. 

  1963.     vector<int> parsed_chan_in_list;

  1964.     vector<int> parsed_chan_out_list;

  1965. 

  1966.     ParseChannelList(chan_in_list, parsed_chan_in_list);

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

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

  1969.         inchannels = parsed_chan_in_list.size();

  1970.     }

  1971. 

  1972.     ParseChannelList(chan_out_list, parsed_chan_out_list);

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

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

  1975.         outchannels = parsed_chan_out_list.size();

  1976.     }

  1977. 

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

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

  1980.         CFRunLoopRef theRunLoop = NULL;

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

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

  1983.         if (osErr != noErr) {

  1984.             jack_error("Open kAudioHardwarePropertyRunLoop error");

  1985.             printError(osErr);

  1986.         }

  1987.     }

  1988.   

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

  1990.         goto error;

  1991.     }

  1992. 

  1993.     // Generic JackAudioDriver Open

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

  1995.                             capturing, playing,

  1996.                             inchannels, outchannels,

  1997.                             monitor,

  1998.                             capture_driver_name,

  1999.                             playback_driver_name,

  2000.                             capture_latency,

  2001.                             playback_latency) != 0) {

  2002.         goto error;

  2003.     }

  2004. 

  2005.     if (SetupChannels(capturing, playing, inchannels, outchannels, in_nChannels, out_nChannels, !ac3_encoding) < 0) {

  2006.         goto error;

  2007.     }

  2008. 

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

  2010.         goto error;

  2011.     }

  2012. 

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

  2014.         goto error;

  2015.     }

  2016.     

  2017.     if (ac3_encoding) {

  2018.     

  2019.         if (!IsDigitalDevice(fDeviceID)) {

  2020.             jack_error("AC3 encoding can only be used with a digital device");

  2021.             goto error;

  2022.         }

  2023.         

  2024.         // Force hogged mode

  2025.         fHogged = true;

  2026.         if (TakeHog()) {

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

  2028.         }

  2029.         

  2030.         JackAC3EncoderParams params;

  2031.         memset(&params, 0, sizeof(JackAC3EncoderParams));

  2032.         params.bitrate = ac3_bitrate;

  2033.         params.channels = outchannels;

  2034.         params.sample_rate = sample_rate;

  2035.         params.lfe = ac3_lfe;

  2036.         fAC3Encoder = new JackAC3Encoder(params);

  2037.         

  2038.         if (!fAC3Encoder || !fAC3Encoder->Init(sample_rate)) {

  2039.             jack_error("Cannot allocate of init AC3 encoder");

  2040.             goto error;

  2041.         }

  2042.         

  2043.         // Setup AC3 channel number

  2044.         fPlaybackChannels = outchannels;

  2045.         if (ac3_lfe) {

  2046.             fPlaybackChannels++;

  2047.         }

  2048.         

  2049.         if (fPlaybackChannels < 2 || fPlaybackChannels > 6) {

  2050.             jack_error("AC3 encoder channels must be between 2 and 6");

  2051.             goto error;

  2052.         }

  2053.         

  2054.         // Force real output channel number to 2

  2055.         outchannels = out_nChannels = 2;

  2056.         

  2057.     } else {

  2058.         fPlaybackChannels = outchannels;

  2059.     }

  2060.     

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

  2062.     fCaptureChannels = inchannels;

  2063. 

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

  2065.         goto error;

  2066.     }

  2067. 

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

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

  2070.             goto error;

  2071.         }

  2072.     }

  2073. 

  2074.     if (AddListeners() < 0) {

  2075.         goto error;

  2076.     }

  2077.   

  2078.     return noErr;

  2079. 

  2080. error:

  2081.     Close();

  2082.     return -1;

  2083. }

  2084. 

  2085. int JackCoreAudioDriver::Close()

  2086. {

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

  2088. 

  2089.     // Generic audio driver close

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

  2091. 

  2092.     RemoveListeners();

  2093.     DisposeBuffers();

  2094.     CloseAUHAL();

  2095.     DestroyAggregateDevice();

  2096.     return res;

  2097. }

  2098. 

  2099. void JackCoreAudioDriver::UpdateLatencies()

  2100. {

  2101.     UInt32 size;

  2102.     OSStatus err;

  2103.     jack_latency_range_t input_range;

  2104.     jack_latency_range_t output_range;

  2105.     jack_latency_range_t monitor_range;

  2106. 

  2107.     // Get Input latency

  2108.     size = sizeof(UInt32);

  2109.     UInt32 value1 = 0;

  2110.     UInt32 value2 = 0;

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

  2112.     if (err != noErr) {

  2113.         jack_error("AudioDeviceGetProperty kAudioDevicePropertyLatency error");

  2114.     }

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

  2116.     if (err != noErr) {

  2117.         jack_error("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");

  2118.     }

  2119. 

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

  2121. 

  2122.     // Get input stream latencies

  2123.     vector<int> input_latencies;

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

  2125. 

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

  2127.         if (err != noErr) {

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

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

  2130.         }

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

  2132.     }

  2133. 

  2134.     // Get Output latency

  2135.     size = sizeof(UInt32);

  2136.     value1 = 0;

  2137.     value2 = 0;

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

  2139.     if (err != noErr) {

  2140.         jack_error("AudioDeviceGetProperty kAudioDevicePropertyLatency error");

  2141.     }

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

  2143.     if (err != noErr) {

  2144.         jack_error("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");

  2145.     }

  2146. 

  2147.     // Get output stream latencies

  2148.     vector<int> output_latencies;

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

  2150. 

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

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

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

  2154. 

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

  2156.         if (err != noErr) {

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

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

  2159.         }

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

  2161. 

  2162.         // Monitor port

  2163.         if (fWithMonitorPorts) {

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

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

  2166.         }

  2167.     }

  2168. }

  2169. 

  2170. int JackCoreAudioDriver::Attach()

  2171. {

  2172.     OSStatus err;

  2173.     JackPort* port;

  2174.     jack_port_id_t port_index;

  2175.     UInt32 size;

  2176.     Boolean isWritable;

  2177.     char channel_name[64];

  2178.     char name[REAL_JACK_PORT_NAME_SIZE];

  2179.     char alias[REAL_JACK_PORT_NAME_SIZE];

  2180. 

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

  2182. 

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

  2184. 

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

  2186.         if (err != noErr) {

  2187.             jack_log("JackCoreAudioDriver::Attach : AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error");

  2188.         }

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

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

  2191.             if (err != noErr) {

  2192.                 jack_log("JackCoreAudioDriver::Attach : AudioDeviceGetProperty kAudioDevicePropertyChannelName error");

  2193.             }

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

  2195.         } else {

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

  2197.         }

  2198. 

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

  2200. 

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

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

  2203.             return -1;

  2204.         }

  2205. 

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

  2207.         port->SetAlias(alias);

  2208.         fCapturePortList[i] = port_index;

  2209.     }

  2210. 

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

  2212. 

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

  2214.         if (err != noErr) {

  2215.             jack_log("JackCoreAudioDriver::Attach : AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error");

  2216.         }

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

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

  2219.             if (err != noErr) {

  2220.                 jack_log("JackCoreAudioDriver::Attach : AudioDeviceGetProperty kAudioDevicePropertyChannelName error");

  2221.             }

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

  2223.         } else {

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

  2225.         }

  2226. 

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

  2228. 

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

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

  2231.             return -1;

  2232.         }

  2233. 

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

  2235.         port->SetAlias(alias);

  2236.         fPlaybackPortList[i] = port_index;

  2237. 

  2238.         // Monitor ports

  2239.         if (fWithMonitorPorts) {

  2240.             jack_log("JackCoreAudioDriver::Attach : create monitor port");

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

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

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

  2244.                 return -1;

  2245.             } else {

  2246.                 fMonitorPortList[i] = port_index;

  2247.             }

  2248.         }

  2249.     }

  2250.     

  2251.     if (fAC3Encoder) {

  2252.         // Setup specific AC3 channels names

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

  2254.             fAC3Encoder->GetChannelName("coreaudio", "", alias, i);

  2255.             port = fGraphManager->GetPort(fPlaybackPortList[i]);

  2256.             port->SetAlias(alias);

  2257.         }

  2258.     }

  2259. 

  2260.     UpdateLatencies();

  2261. 

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

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

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

  2265.     }

  2266. 

  2267.     return 0;

  2268. }

  2269. 

  2270. int JackCoreAudioDriver::Start()

  2271. {

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

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

  2274. 

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

  2276.         fState = false;

  2277.         int count = 0;

  2278. 

  2279.         OSStatus err = AudioOutputUnitStart(fAUHAL);

  2280.         if (err == noErr) {

  2281. 

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

  2283.                 usleep(100000);

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

  2285.             }

  2286. 

  2287.             if (count < WAIT_COUNTER) {

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

  2289.                 return 0;

  2290.             }

  2291. 

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

  2293.         }

  2294.         JackAudioDriver::Stop();

  2295.     }

  2296.     return -1;

  2297. }

  2298. 

  2299. int JackCoreAudioDriver::Stop()

  2300. {

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

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

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

  2304.         res = -1;

  2305.     }

  2306.     return res;

  2307. }

  2308. 

  2309. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  2310. {

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

  2312.         return -1;

  2313.     }

  2314. 

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

  2316. 

  2317.     // CoreAudio specific

  2318.     UpdateLatencies();

  2319. 

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

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

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

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

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

  2325.     }

  2326. 

  2327.     return 0;

  2328. }

  2329. 

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

  2331. {

  2332.     pid_t hog_pid;

  2333.     OSStatus err;

  2334. 

  2335.     UInt32 propSize = sizeof(hog_pid);

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

  2337.     if (err) {

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

  2339.         printError(err);

  2340.     }

  2341. 

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

  2343.         hog_pid = getpid();

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

  2345.         if (err != noErr) {

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

  2347.             return false;

  2348.         }

  2349.     }

  2350. 

  2351.     return true;

  2352. }

  2353. 

  2354. bool JackCoreAudioDriver::TakeHog()

  2355. {

  2356.     OSStatus err = noErr;

  2357.     AudioObjectID sub_device[32];

  2358.     UInt32 outSize = sizeof(sub_device);

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

  2360. 

  2361.     if (err != noErr) {

  2362.         jack_log("JackCoreAudioDriver::TakeHog : device does not have subdevices");

  2363.         return TakeHogAux(fDeviceID, true);

  2364.     } else {

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

  2366.         jack_log("JackCoreAudioDriver::TakeHog : device does has %d subdevices", num_devices);

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

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

  2369.                 return false;

  2370.             }

  2371.         }

  2372.         return true;

  2373.     }

  2374. }

  2375. 

  2376. bool JackCoreAudioDriver::IsAggregateDevice(AudioDeviceID device)

  2377. {

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

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

  2380. 

  2381.     if (err != noErr) {

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

  2383.         return false;

  2384.     } else {

  2385.         return (deviceType == kAudioDeviceTransportTypeAggregate);

  2386.     }

  2387. }

  2388. 

  2389. 

  2390. } // end of namespace

  2391. 

  2392. 

  2393. #ifdef __cplusplus

  2394. extern "C"

  2395. {

  2396. #endif

  2397. 

  2398.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor()

  2399.     {

  2400.         jack_driver_desc_t * desc;

  2401.         jack_driver_desc_filler_t filler;

  2402.         jack_driver_param_value_t value;

  2403. 

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

  2405. 

  2406.         value.i = -1;

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

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

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

  2410. 

  2411.         value.str[0] = 0;

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

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

  2414. 

  2415.         value.str[0] = 0;

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

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

  2418. 

  2419.         value.i  = 0;

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

  2421.         

  2422.         value.i  = 0;

  2423.         jack_driver_descriptor_add_parameter(desc, &filler, "AC3-encoding", 'a', JackDriverParamBool, &value, NULL, "AC3 multi-channels encoding", NULL);

  2424.         

  2425.         value.i  = 448;

  2426.         jack_driver_descriptor_add_parameter(desc, &filler, "AC3-bitrate", 'b', JackDriverParamUInt, &value, NULL, "AC3 bitrate", NULL);

  2427.        

  2428.         value.i  = 0;

  2429.         jack_driver_descriptor_add_parameter(desc, &filler, "AC3-LFE", 'f', JackDriverParamBool, &value, NULL, "AC3 LFE channel", NULL);

  2430. 

  2431.         value.i  = TRUE;

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

  2433. 

  2434.         value.ui  = 44100U;

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

  2436. 

  2437.         value.ui  = 256U;

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

  2439. 

  2440.         value.str[0] = 0;

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

  2442. 

  2443.         value.ui  = 0;

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

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

  2446. 

  2447.         value.i  = FALSE;

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

  2449. 

  2450.         value.i  = FALSE;

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

  2452. 

  2453.         value.ui  = 100;

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

  2455. 

  2456.         value.ui  = 100;

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

  2458. 

  2459.         value.i = FALSE;

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

  2461. 

  2462.         return desc;

  2463.     }

  2464. 

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

  2466.     {

  2467.         jack_nframes_t srate = 44100;

  2468.         jack_nframes_t frames_per_interrupt = 256;

  2469.         bool capture = false;

  2470.         bool playback = false;

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

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

  2473.         const char* chan_in_list = "";

  2474.         const char* chan_out_list = "";

  2475.         bool monitor = false;

  2476.         const char* capture_driver_uid = "";

  2477.         const char* playback_driver_uid = "";

  2478.         const JSList *node;

  2479.         const jack_driver_param_t *param;

  2480.         jack_nframes_t systemic_input_latency = 0;

  2481.         jack_nframes_t systemic_output_latency = 0;

  2482.         int async_output_latency = 100;

  2483.         int computation_grain = -1;

  2484.         bool hogged = false;

  2485.         bool clock_drift = false;

  2486.         bool ac3_encoding = false;

  2487.         int ac3_bitrate = 448;

  2488.         bool ac3_lfe = false;

  2489. 

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

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

  2492. 

  2493.             switch (param->character) {

  2494. 

  2495.                 case 'd':

  2496.                     capture_driver_uid = param->value.str;

  2497.                     playback_driver_uid = param->value.str;

  2498.                     break;

  2499. 

  2500.                 case 'D':

  2501.                     capture = true;

  2502.                     playback = true;

  2503.                     break;

  2504. 

  2505.                 case 'c':

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

  2507.                     break;

  2508. 

  2509.                 case 'i':

  2510.                     chan_in = param->value.i;

  2511.                     break;

  2512. 

  2513.                 case 'o':

  2514.                     chan_out = param->value.i;

  2515.                     break;

  2516. 

  2517.                 case 'n':

  2518.                     chan_in_list = param->value.str;

  2519.                     break;

  2520. 

  2521.                 case 'N':

  2522.                     chan_out_list = param->value.str;

  2523.                     break;

  2524. 

  2525.                 case 'C':

  2526.                     capture = true;

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

  2528.                         capture_driver_uid = param->value.str;

  2529.                     }

  2530.                     break;

  2531. 

  2532.                 case 'P':

  2533.                     playback = true;

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

  2535.                         playback_driver_uid = param->value.str;

  2536.                     }

  2537.                     break;

  2538. 

  2539.                 case 'm':

  2540.                     monitor = param->value.i;

  2541.                     break;

  2542.                     

  2543.                 case 'a':

  2544.                     ac3_encoding = param->value.i;

  2545.                     break;

  2546.                     

  2547.                 case 'b':

  2548.                     ac3_bitrate = param->value.i;

  2549.                     break;

  2550.                     

  2551.                 case 'f':

  2552.                     ac3_lfe = param->value.i;

  2553.                     break;

  2554. 

  2555.                 case 'r':

  2556.                     srate = param->value.ui;

  2557.                     break;

  2558. 

  2559.                 case 'p':

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

  2561.                     break;

  2562. 

  2563.                 case 'I':

  2564.                     systemic_input_latency = param->value.ui;

  2565.                     break;

  2566. 

  2567.                 case 'O':

  2568.                     systemic_output_latency = param->value.ui;

  2569.                     break;

  2570. 

  2571.                 case 'l':

  2572.                     Jack::DisplayDeviceNames();

  2573.                     // Stops the server in this case

  2574.                     return NULL;

  2575. 

  2576.                 case 'H':

  2577.                     hogged = true;

  2578.                     break;

  2579. 

  2580.                 case 'L':

  2581.                     async_output_latency = param->value.ui;

  2582.                     break;

  2583. 

  2584.                 case 'G':

  2585.                     computation_grain = param->value.ui;

  2586.                     break;

  2587. 

  2588.                 case 's':

  2589.                     clock_drift = true;

  2590.                     break;

  2591.             }

  2592.         }

  2593. 

  2594.         /* duplex is the default */

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

  2596.             capture = true;

  2597.             playback = true;

  2598.         }

  2599. 

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

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

  2602.         }

  2603. 

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

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

  2606.         }

  2607. 

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

  2609.         if (driver->Open(frames_per_interrupt,

  2610.                         srate, capture,

  2611.                         playback, chan_in,

  2612.                         chan_out, chan_in_list,

  2613.                         chan_out_list, monitor,

  2614.                         capture_driver_uid,

  2615.                         playback_driver_uid,

  2616.                         systemic_input_latency,

  2617.                         systemic_output_latency,

  2618.                         async_output_latency,

  2619.                         computation_grain,

  2620.                         hogged, clock_drift, 

  2621.                         ac3_encoding, ac3_bitrate, ac3_lfe) == 0) {

  2622.             return driver;

  2623.         } else {

  2624.             delete driver;

  2625.             return NULL;

  2626.         }

  2627.     }

  2628. 

  2629. #ifdef __cplusplus

  2630. }

  2631. #endif

  2632.