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

2725 lines
106KB
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 (strncmp(device_name_aux, device_name, strlen(device_name)) == 0) {

  162.             *device_id = devices[i];

  163.             return true;

  164.         }

  165.     }

  166. 

  167.     return false;

  168. }

  169. 

  170. static bool CheckAvailableDevice(AudioDeviceID device_id)

  171. {

  172.     UInt32 size;

  173.     Boolean isWritable;

  174.     int i, deviceNum;

  175.     OSStatus err;

  176. 

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

  178.     if (err != noErr) {

  179.         return false;

  180.     }

  181. 

  182.     deviceNum = size / sizeof(AudioDeviceID);

  183.     AudioDeviceID devices[deviceNum];

  184. 

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

  186.     if (err != noErr) {

  187.         return false;

  188.     }

  189. 

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

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

  192.             return true;

  193.         }

  194.     }

  195. 

  196.     return false;

  197. }

  198. 

  199. 

  200. static OSStatus DisplayDeviceNames()

  201. {

  202.     UInt32 size;

  203.     Boolean isWritable;

  204.     int i, deviceNum;

  205.     OSStatus err;

  206.     CFStringRef UIname;

  207. 

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

  209.     if (err != noErr) {

  210.         return err;

  211.     }

  212. 

  213.     deviceNum = size / sizeof(AudioDeviceID);

  214.     AudioDeviceID devices[deviceNum];

  215. 

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

  217.     if (err != noErr) {

  218.         return err;

  219.     }

  220. 

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

  222.         char device_name[256];

  223.         char internal_name[256];

  224. 

  225.         size = sizeof(CFStringRef);

  226.         UIname = NULL;

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

  228.         if (err == noErr) {

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

  230.         } else {

  231.             goto error;

  232.         }

  233. 

  234.         size = 256;

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

  236.         if (err != noErr) {

  237.             return err;

  238.         }

  239. 

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

  241.     }

  242. 

  243.     return noErr;

  244. 

  245. error:

  246.     if (UIname != NULL) {

  247.         CFRelease(UIname);

  248.     }

  249.     return err;

  250. }

  251. 

  252. static CFStringRef GetDeviceName(AudioDeviceID id)

  253. {

  254.     UInt32 size = sizeof(CFStringRef);

  255.     CFStringRef UIname;

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

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

  258. }

  259. 

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

  261. {

  262.     stringstream ss(list);

  263.     string token;

  264.     int chan;

  265.   

  266.     while (ss >> token) {

  267.         istringstream ins;

  268.         ins.str(token);

  269.         ins >> chan;

  270.         if (chan < 0 || chan >= max_chan) {

  271.             jack_error("Ignore incorrect channel mapping value = %d", chan);

  272.         } else {

  273.             result.push_back(chan);

  274.         }

  275.     }

  276. }

  277. 

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

  279.                                      AudioUnitRenderActionFlags* ioActionFlags,

  280.                                      const AudioTimeStamp* inTimeStamp,

  281.                                      UInt32 inBusNumber,

  282.                                      UInt32 inNumberFrames,

  283.                                      AudioBufferList* ioData)

  284. {

  285.     return static_cast<JackCoreAudioDriver*>(inRefCon)->Render(ioActionFlags, inTimeStamp, ioData);

  286. }

  287. 

  288. OSStatus JackCoreAudioDriver::Render(AudioUnitRenderActionFlags* ioActionFlags, const AudioTimeStamp* inTimeStamp,  AudioBufferList* ioData)

  289. {

  290.     fActionFags = ioActionFlags;

  291.     fCurrentTime = inTimeStamp;

  292.     fDriverOutputData = ioData;

  293. 

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

  295.     if (set_threaded_log_function()) {

  296. 

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

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

  299. 

  300.         if (fComputationGrain > 0) {

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

  302.             fEngineControl->fComputation = fEngineControl->fPeriod * fComputationGrain;

  303.         }

  304.     }

  305. 

  306.     // Signal waiting start function...

  307.     fState = true;

  308. 

  309.     CycleTakeBeginTime();

  310. 

  311.     if (Process() < 0) {

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

  313.         NotifyFailure(JackFailure | JackBackendError, "Process error, stopping driver");    // Message length limited to JACK_MESSAGE_SIZE

  314.         Stop();

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

  316.         return kAudioHardwareUnsupportedOperationError;

  317.     } else {

  318.         return noErr;

  319.     }

  320. }

  321. 

  322. int JackCoreAudioDriver::Read()

  323. {

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

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

  326.     } else {

  327.         return 0;

  328.     }

  329. }

  330. 

  331. int JackCoreAudioDriver::Write()

  332. {

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

  334.     

  335.     if (fAC3Encoder) {

  336.     

  337.         // AC3 encoding and SPDIF write

  338.         jack_default_audio_sample_t* AC3_inputs[MAX_AC3_CHANNELS];

  339.         jack_default_audio_sample_t* AC3_outputs[2];

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

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

  342.             // If not connected, clear the buffer

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

  344.                 memset(AC3_inputs[i], 0, size);

  345.             }

  346.         }

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

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

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

  350.         

  351.     } else {

  352.        

  353.         // Standard write

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

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

  356.                 jack_default_audio_sample_t* buffer = GetOutputBuffer(i);

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

  358.                 // Monitor ports

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

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

  361.                 }

  362.             } else {

  363.                 memset((jack_default_audio_sample_t*)fDriverOutputData->mBuffers[i].mData, 0, size);

  364.             }

  365.         }

  366.     }

  367.     return 0;

  368. }

  369. 

  370. OSStatus JackCoreAudioDriver::SRNotificationCallback(AudioDeviceID inDevice,

  371.                                                     UInt32 inChannel,

  372.                                                     Boolean	isInput,

  373.                                                     AudioDevicePropertyID inPropertyID,

  374.                                                     void* inClientData)

  375. {

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

  377. 

  378.     switch (inPropertyID) {

  379. 

  380.         case kAudioDevicePropertyNominalSampleRate: {

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

  382.             // Check new sample rate

  383.             Float64 tmp_sample_rate;

  384.             UInt32 outSize = sizeof(Float64);

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

  386.             if (err != noErr) {

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

  388.                 printError(err);

  389.             } else {

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

  391.             }

  392.             driver->fState = true;

  393.             break;

  394.         }

  395.     }

  396. 

  397.     return noErr;

  398. }

  399. 

  400. OSStatus JackCoreAudioDriver::BSNotificationCallback(AudioDeviceID inDevice,

  401.                                                      UInt32 inChannel,

  402.                                                      Boolean isInput,

  403.                                                      AudioDevicePropertyID inPropertyID,

  404.                                                      void* inClientData)

  405. {

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

  407. 

  408.     switch (inPropertyID) {

  409. 

  410.         case kAudioDevicePropertyBufferFrameSize: {

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

  412.             // Check new buffer size

  413.             UInt32 tmp_buffer_size;

  414.             UInt32 outSize = sizeof(UInt32);

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

  416.             if (err != noErr) {

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

  418.                 printError(err);

  419.             } else {

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

  421.             }

  422.             driver->fState = true;

  423.             break;

  424.         }

  425.     }

  426. 

  427.     return noErr;

  428. }

  429. 

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

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

  432. {

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

  434. 

  435.     switch (inPropertyID) {

  436. 

  437.         case kAudioHardwarePropertyDevices: {

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

  439.             DisplayDeviceNames();

  440.             AudioDeviceID captureID, playbackID;

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

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

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

  444. 

  445.             }

  446.             break;

  447.         }

  448.     }

  449. 

  450.     return noErr;

  451. }

  452. 

  453. OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,

  454.                                                         UInt32 inChannel,

  455.                                                         Boolean	isInput,

  456.                                                         AudioDevicePropertyID inPropertyID,

  457.                                                         void* inClientData)

  458. {

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

  460. 

  461.     switch (inPropertyID) {

  462. 

  463.         case kAudioDevicePropertyDeviceIsRunning: {

  464.             UInt32 isrunning = 0;

  465.             UInt32 outsize = sizeof(UInt32);

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

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

  468.             }

  469.             break;

  470.         }

  471. 

  472.         case kAudioDevicePropertyDeviceIsAlive: {

  473.             UInt32 isalive = 0;

  474.             UInt32 outsize = sizeof(UInt32);

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

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

  477.             }

  478.             break;

  479.         }

  480. 

  481.         case kAudioDevicePropertyDeviceHasChanged: {

  482.             UInt32 hachanged = 0;

  483.             UInt32 outsize = sizeof(UInt32);

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

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

  486.             }

  487.             break;

  488.         }

  489. 

  490.         case kAudioDeviceProcessorOverload: {

  491.             jack_error("DeviceNotificationCallback kAudioDeviceProcessorOverload");

  492.             jack_time_t cur_time = GetMicroSeconds();

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

  494.             break;

  495.         }

  496. 

  497.         case kAudioDevicePropertyStreamConfiguration: {

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

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

  500.             driver->CloseAUHAL();

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

  502.             return kAudioHardwareUnsupportedOperationError;

  503.         }

  504. 

  505.         case kAudioDevicePropertyNominalSampleRate: {

  506.             Float64 sample_rate = 0;

  507.             UInt32 outsize = sizeof(Float64);

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

  509.             if (err != noErr) {

  510.                 return kAudioHardwareUnsupportedOperationError;

  511.             }

  512. 

  513.             char device_name[256];

  514.             const char* digidesign_name = "Digidesign";

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

  516. 

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

  518. 

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

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

  521. 

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

  523. 

  524.                     // Set sample rate again...

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

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

  527.                     if (err != noErr) {

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

  529.                         printError(err);

  530.                     } else {

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

  532.                     }

  533. 

  534.                     // Check new sample rate again...

  535.                     outsize = sizeof(Float64);

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

  537.                     if (err != noErr) {

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

  539.                         printError(err);

  540.                     } else {

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

  542.                     }

  543.                     return noErr;

  544. 

  545.                 } else {

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

  547.                     driver->CloseAUHAL();

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

  549.                     return kAudioHardwareUnsupportedOperationError;

  550.                 }

  551.             }

  552.         }

  553. 

  554.     }

  555.     return noErr;

  556. }

  557. 

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

  559. {

  560.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  563. 

  564.     if (inIUD == NULL) {

  565.         return kAudioHardwareUnspecifiedError;

  566.     } else {

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

  568.         CFRelease(inIUD);

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

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

  571.     }

  572. }

  573. 

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

  575. {

  576.     OSStatus res;

  577.     UInt32 theSize = sizeof(UInt32);

  578.     AudioDeviceID inDefault;

  579.     AudioDeviceID outDefault;

  580. 

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

  582.         return res;

  583.     }

  584. 

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

  586.         return res;

  587.     }

  588. 

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

  590. 

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

  592.     if (inDefault != outDefault) {

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

  594.         return kAudioHardwareBadDeviceError;

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

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

  597.         return kAudioHardwareBadDeviceError;

  598.     } else {

  599.         *id = inDefault;

  600.         return noErr;

  601.     }

  602. }

  603. 

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

  605. {

  606.     OSStatus res;

  607.     UInt32 theSize = sizeof(UInt32);

  608.     AudioDeviceID inDefault;

  609. 

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

  611.         return res;

  612.     }

  613. 

  614.     if (inDefault == 0) {

  615.         jack_error("Error default input device is 0, will take 'Built-in'...");

  616.         if (CheckAvailableDeviceName("Built-in Microphone", id) 

  617.             || CheckAvailableDeviceName("Built-in Line", id)) {

  618.              jack_log("JackCoreAudioDriver::GetDefaultInputDevice : output = %ld", *id);

  619.             return noErr;

  620.         } else {

  621.             jack_error("Cannot find any input device to use...");

  622.             return -1;

  623.         }

  624.     }

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

  626.     *id = inDefault;

  627.     return noErr;

  628. }

  629. 

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

  631. {

  632.     OSStatus res;

  633.     UInt32 theSize = sizeof(UInt32);

  634.     AudioDeviceID outDefault;

  635. 

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

  637.         return res;

  638.     }

  639. 

  640.     if (outDefault == 0) {

  641.         jack_error("Error default ouput device is 0, will take 'Built-in'...");

  642.         if (CheckAvailableDeviceName("Built-in Output", id)) {

  643.             jack_log("JackCoreAudioDriver::GetDefaultOutputDevice : output = %ld", *id);

  644.             return noErr;

  645.         } else {

  646.             jack_error("Cannot find any output device to use...");

  647.             return -1;

  648.         }

  649.     }

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

  651.     *id = outDefault;

  652.     return noErr;

  653. }

  654. 

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

  656. {

  657.     UInt32 size = 256;

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

  659. }

  660. 

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

  662. {

  663.     OSStatus err = noErr;

  664.     UInt32 outSize;

  665.     Boolean	outWritable;

  666. 

  667.     channelCount = 0;

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

  669.     if (err == noErr) {

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

  671.         jack_log("JackCoreAudioDriver::GetTotalChannels stream_count = %d", stream_count);

  672.         AudioBufferList bufferList[stream_count];

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

  674.         if (err == noErr) {

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

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

  677.                 jack_log("JackCoreAudioDriver::GetTotalChannels stream = %d channels = %d", i, bufferList->mBuffers[i].mNumberChannels);

  678.             }

  679.         }

  680.     }

  681.     return err;

  682. }

  683. 

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

  685. {

  686.     OSStatus err = noErr;

  687.     UInt32 outSize1, outSize2, outSize3;

  688.     Boolean	outWritable;

  689. 

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

  691.     if (err == noErr) {

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

  693.         AudioStreamID streamIDs[stream_count];

  694.         AudioBufferList bufferList[stream_count];

  695.         UInt32 streamLatency;

  696.         outSize2 = sizeof(UInt32);

  697. 

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

  699.         if (err != noErr) {

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

  701.             return err;

  702.         }

  703. 

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

  705.         if (err != noErr) {

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

  707.             return err;

  708.         }

  709. 

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

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

  712.             if (err != noErr) {

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

  714.                 return err;

  715.             }

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

  717.             if (err != noErr) {

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

  719.                 return err;

  720.             }

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

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

  723.                 latencies.push_back(streamLatency);

  724.             }

  725.         }

  726.     }

  727.     return err;

  728. }

  729. 

  730. bool JackCoreAudioDriver::IsDigitalDevice(AudioDeviceID device)

  731. {

  732.     OSStatus err = noErr;

  733.     UInt32 outSize1;

  734.     bool is_digital = false;

  735.     

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

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

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

  739.     if (err != noErr) {

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

  741.         return false;

  742.     }

  743.     

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

  745.     AudioStreamID streamIDs[stream_count];

  746.     

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

  748. 

  749.     if (err != noErr) {

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

  751.         return false;

  752.     }

  753.     

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

  755.      

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

  757.    

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

  759.         int  format_num = 0;

  760.     

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

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

  763.         

  764.         if (err != noErr) {

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

  766.             return false;

  767.         }

  768. 

  769.         format_num = outSize1 / sizeof(AudioStreamRangedDescription);

  770.         AudioStreamRangedDescription format_list[format_num];

  771.       

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

  773.          

  774.         if (err != noErr) {

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

  776.             return false;

  777.         }

  778.    

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

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

  781.         

  782.             PrintStreamDesc(&format_list[j].mFormat);

  783.             

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

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

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

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

  788.             {

  789.                 is_digital = true;

  790.                 break;

  791.             }

  792.         }

  793.     }

  794.        

  795.     return is_digital;

  796. }

  797. 

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

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

  800.         fAC3Encoder(NULL),

  801.         fJackInputData(NULL),

  802.         fDriverOutputData(NULL),

  803.         fPluginID(0),

  804.         fState(false),

  805.         fHogged(false),

  806.         fIOUsage(1.f),

  807.         fComputationGrain(-1.f),

  808.         fClockDriftCompensate(false),

  809.         fDigitalPlayback(false)

  810. {}

  811. 

  812. JackCoreAudioDriver::~JackCoreAudioDriver()

  813. {

  814.     delete fAC3Encoder;

  815. }

  816. 

  817. OSStatus JackCoreAudioDriver::DestroyAggregateDevice()

  818. {

  819.     OSStatus osErr = noErr;

  820.     AudioObjectPropertyAddress pluginAOPA;

  821.     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;

  822.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  823.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  824.     UInt32 outDataSize;

  825. 

  826.     if (fPluginID > 0) {

  827. 

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

  829.         if (osErr != noErr) {

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

  831.             printError(osErr);

  832.             return osErr;

  833.         }

  834. 

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

  836.         if (osErr != noErr) {

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

  838.             printError(osErr);

  839.             return osErr;

  840.         }

  841. 

  842.     }

  843. 

  844.     return noErr;

  845. }

  846. 

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

  848. {

  849.     OSStatus err = noErr;

  850.     AudioObjectID sub_device[32];

  851.     UInt32 outSize = sizeof(sub_device);

  852. 

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

  854.     vector<AudioDeviceID> captureDeviceIDArray;

  855.     

  856.     jack_log("JackCoreAudioDriver::CreateAggregateDevice : input device %d", captureDeviceID);

  857. 

  858.     if (err != noErr) {

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

  860.         captureDeviceIDArray.push_back(captureDeviceID);

  861.     } else {

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

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

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

  865.             jack_log("JackCoreAudioDriver::CreateAggregateDevice : input sub_device %d", sub_device[i]);

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

  867.         }

  868.     }

  869. 

  870.     outSize = sizeof(sub_device);

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

  872.     vector<AudioDeviceID> playbackDeviceIDArray;

  873.     

  874.     jack_log("JackCoreAudioDriver::CreateAggregateDevice : output device %d", playbackDeviceID);

  875. 

  876.     if (err != noErr) {

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

  878.         playbackDeviceIDArray.push_back(playbackDeviceID);

  879.     } else {

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

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

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

  883.             jack_log("JackCoreAudioDriver::CreateAggregateDevice : output sub_device %d", sub_device[i]);

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

  885.         }

  886.     }

  887. 

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

  889. }

  890. 

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

  892. {

  893.     OSStatus osErr = noErr;

  894.     UInt32 outSize;

  895.     Boolean outWritable;

  896. 

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

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

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

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

  901.     UInt32 theQualifierDataSize = sizeof(AudioObjectID);

  902.     AudioClassID inClass = kAudioSubDeviceClassID;

  903.     void* theQualifierData = &inClass;

  904.     UInt32 subDevicesNum = 0;

  905. 

  906.     //---------------------------------------------------------------------------

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

  908.     //---------------------------------------------------------------------------

  909.     UInt32 keptclockdomain = 0;

  910.     UInt32 clockdomain = 0;

  911.     outSize = sizeof(UInt32);

  912.     bool need_clock_drift_compensation = false;

  913. 

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

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

  916.             jack_error("CreateAggregateDeviceAux : cannot set SR of input device");

  917.         } else  {

  918.             // Check clock domain

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

  920.             if (osErr != 0) {

  921.                 jack_error("CreateAggregateDeviceAux : kAudioDevicePropertyClockDomain error");

  922.                 printError(osErr);

  923.             } else {

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

  925.                 jack_log("JackCoreAudioDriver::CreateAggregateDeviceAux : input clockdomain = %d", clockdomain);

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

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

  928.                     need_clock_drift_compensation = true;

  929.                 }

  930.             }

  931.         }

  932.     }

  933. 

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

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

  936.             jack_error("CreateAggregateDeviceAux : cannot set SR of output device");

  937.         } else {

  938.             // Check clock domain

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

  940.             if (osErr != 0) {

  941.                 jack_error("CreateAggregateDeviceAux : kAudioDevicePropertyClockDomain error");

  942.                 printError(osErr);

  943.             } else {

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

  945.                 jack_log("JackCoreAudioDriver::CreateAggregateDeviceAux : output clockdomain = %d", clockdomain);

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

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

  948.                     need_clock_drift_compensation = true;

  949.                 }

  950.             }

  951.         }

  952.     }

  953. 

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

  955.     if (keptclockdomain == 0) {

  956.         need_clock_drift_compensation = true;

  957.     }

  958. 

  959.     //---------------------------------------------------------------------------

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

  961.     //---------------------------------------------------------------------------

  962. 

  963.     char device_name[256];

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

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

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

  967.     }

  968. 

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

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

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

  972.     }

  973. 

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

  975.     if (osErr != noErr) {

  976.         jack_error("CreateAggregateDeviceAux : AudioHardwareGetPropertyInfo kAudioHardwarePropertyPlugInForBundleID error");

  977.         printError(osErr);

  978.         return osErr;

  979.     }

  980. 

  981.     AudioValueTranslation pluginAVT;

  982. 

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

  984. 

  985.     pluginAVT.mInputData = &inBundleRef;

  986.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  987.     pluginAVT.mOutputData = &fPluginID;

  988.     pluginAVT.mOutputDataSize = sizeof(fPluginID);

  989. 

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

  991.     if (osErr != noErr) {

  992.         jack_error("CreateAggregateDeviceAux : AudioHardwareGetProperty kAudioHardwarePropertyPlugInForBundleID error");

  993.         printError(osErr);

  994.         return osErr;

  995.     }

  996. 

  997.     //-------------------------------------------------

  998.     // Create a CFDictionary for our aggregate device

  999.     //-------------------------------------------------

  1000. 

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

  1002. 

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

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

  1005. 

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

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

  1008. 

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

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

  1011. 

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

  1013.     int value = 1;

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

  1015. 

  1016.     SInt32 system;

  1017.     Gestalt(gestaltSystemVersion, &system);

  1018. 

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

  1020. 

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

  1022.     if (system < 0x00001054) {

  1023.         jack_log("JackCoreAudioDriver::CreateAggregateDeviceAux : public aggregate device....");

  1024.     } else {

  1025.         jack_log("JackCoreAudioDriver::CreateAggregateDeviceAux : private aggregate device....");

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

  1027.     }

  1028. 

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

  1030.     CFMutableArrayRef subDevicesArrayClock = NULL;

  1031. 

  1032.     /*

  1033.     if (fClockDriftCompensate) {

  1034.         if (need_clock_drift_compensation) {

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

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

  1037. 

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

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

  1040.                 if (UID) {

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

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

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

  1044.                     //CFRelease(UID);

  1045.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  1046.                 }

  1047.             }

  1048. 

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

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

  1051.                 if (UID) {

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

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

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

  1055.                     //CFRelease(UID);

  1056.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  1057.                 }

  1058.             }

  1059. 

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

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

  1062.         } else {

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

  1064.         }

  1065.     }

  1066.     */

  1067. 

  1068.     //-------------------------------------------------

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

  1070.     //-------------------------------------------------

  1071. 

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

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

  1074. 

  1075.     vector<CFStringRef> captureDeviceUID;

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

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

  1078.         if (ref == NULL) {

  1079.             return -1;

  1080.         }

  1081.         captureDeviceUID.push_back(ref);

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

  1083.         CFArrayAppendValue(subDevicesArray, ref);

  1084.    }

  1085. 

  1086.     vector<CFStringRef> playbackDeviceUID;

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

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

  1089.         if (ref == NULL) {

  1090.             return -1;

  1091.         }

  1092.         playbackDeviceUID.push_back(ref);

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

  1094.         CFArrayAppendValue(subDevicesArray, ref);

  1095.     }

  1096. 

  1097.     //-----------------------------------------------------------------------

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

  1099.     //-----------------------------------------------------------------------

  1100. 

  1101.     AudioObjectPropertyAddress pluginAOPA;

  1102.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  1103.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1104.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1105.     UInt32 outDataSize;

  1106. 

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

  1108.     if (osErr != noErr) {

  1109.         jack_error("CreateAggregateDeviceAux : AudioObjectGetPropertyDataSize error");

  1110.         printError(osErr);

  1111.         goto error;

  1112.     }

  1113. 

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

  1115.     if (osErr != noErr) {

  1116.         jack_error("CreateAggregateDeviceAux : AudioObjectGetPropertyData error");

  1117.         printError(osErr);

  1118.         goto error;

  1119.     }

  1120. 

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

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

  1123.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1124. 

  1125.     //-------------------------

  1126.     // Set the sub-device list

  1127.     //-------------------------

  1128. 

  1129.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  1130.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1131.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1132.     outDataSize = sizeof(CFMutableArrayRef);

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

  1134.     if (osErr != noErr) {

  1135.         jack_error("CreateAggregateDeviceAux : AudioObjectSetPropertyData for sub-device list error");

  1136.         printError(osErr);

  1137.         goto error;

  1138.     }

  1139. 

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

  1141.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1142. 

  1143.     //-----------------------

  1144.     // Set the master device

  1145.     //-----------------------

  1146. 

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

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

  1149.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  1150.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1151.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1152.     outDataSize = sizeof(CFStringRef);

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

  1154.     if (osErr != noErr) {

  1155.         jack_error("CreateAggregateDeviceAux : AudioObjectSetPropertyData for master device error");

  1156.         printError(osErr);

  1157.         goto error;

  1158.     }

  1159. 

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

  1161.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1162. 

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

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

  1165. 

  1166.     if (fClockDriftCompensate) {

  1167.         if (need_clock_drift_compensation) {

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

  1169. 

  1170.             // Get the property data size

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

  1172.             if (osErr != noErr) {

  1173.                 jack_error("CreateAggregateDeviceAux kAudioObjectPropertyOwnedObjects error");

  1174.                 printError(osErr);

  1175.             }

  1176. 

  1177.             //	Calculate the number of object IDs

  1178.             subDevicesNum = outSize / sizeof(AudioObjectID);

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

  1180.             AudioObjectID subDevices[subDevicesNum];

  1181.             outSize = sizeof(subDevices);

  1182. 

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

  1184.             if (osErr != noErr) {

  1185.                 jack_error("CreateAggregateDeviceAux kAudioObjectPropertyOwnedObjects error");

  1186.                 printError(osErr);

  1187.             }

  1188. 

  1189.             // Set kAudioSubDevicePropertyDriftCompensation property...

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

  1191.                 UInt32 theDriftCompensationValue = 1;

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

  1193.                 if (osErr != noErr) {

  1194.                     jack_error("CreateAggregateDeviceAux kAudioSubDevicePropertyDriftCompensation error");

  1195.                     printError(osErr);

  1196.                 }

  1197.             }

  1198.         } else {

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

  1200.         }

  1201.     }

  1202. 

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

  1204.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1205. 

  1206.     //----------

  1207.     // Clean up

  1208.     //----------

  1209. 

  1210.     // release the private AD key

  1211.     CFRelease(AggregateDeviceNumberRef);

  1212. 

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

  1214.     CFRelease(aggDeviceDict);

  1215.     CFRelease(subDevicesArray);

  1216. 

  1217.     if (subDevicesArrayClock) {

  1218.         CFRelease(subDevicesArrayClock);

  1219.     }

  1220. 

  1221.     // release the device UID

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

  1223.         CFRelease(captureDeviceUID[i]);

  1224.     }

  1225. 

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

  1227.         CFRelease(playbackDeviceUID[i]);

  1228.     }

  1229. 

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

  1231.     return noErr;

  1232. 

  1233. error:

  1234.     DestroyAggregateDevice();

  1235.     return -1;

  1236. }

  1237. 

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

  1239.                                       const char* playback_driver_uid,

  1240.                                       char* capture_driver_name,

  1241.                                       char* playback_driver_name,

  1242.                                       jack_nframes_t samplerate,

  1243.                                       bool ac3_encoding)

  1244. {

  1245.     capture_driver_name[0] = 0;

  1246.     playback_driver_name[0] = 0;

  1247. 

  1248.     // Duplex

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

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

  1251. 

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

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

  1254. 

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

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

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

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

  1259.                     return -1;

  1260.                 }

  1261.             }

  1262.             

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

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

  1265.                 return -1;

  1266.             }

  1267.             

  1268.             if (fHogged) {

  1269.                 if (!TakeHogAux(fDeviceID, false)) {

  1270.                     jack_error("Cannot take hog mode");

  1271.                 } 

  1272.                 if (ac3_encoding) {

  1273.                     fDigitalPlayback = IsDigitalDevice(fDeviceID);

  1274.                 }

  1275.             }

  1276. 

  1277.         } else {

  1278. 

  1279.             // Creates aggregate device

  1280.             AudioDeviceID captureID = -1;

  1281.             AudioDeviceID playbackID = -1;

  1282.     

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

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

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

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

  1287.                     return -1;

  1288.                 }

  1289.             }

  1290. 

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

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

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

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

  1295.                     return -1;

  1296.                 }

  1297.             }

  1298. 

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

  1300.                 return -1;

  1301.             }

  1302. 

  1303.             GetDeviceNameFromID(captureID, fCaptureUID);

  1304.             GetDeviceNameFromID(playbackID, fPlaybackUID);

  1305.             

  1306.             if (fHogged) {

  1307.                 if (!TakeHogAux(captureID, true)) {

  1308.                     jack_error("Cannot take hog mode for capture device");

  1309.                 }

  1310.                 if (!TakeHogAux(playbackID, false)) {

  1311.                     jack_error("Cannot take hog mode for playback device");

  1312.                 }

  1313.                 if (ac3_encoding) {

  1314.                     fDigitalPlayback = IsDigitalDevice(playbackID);

  1315.                 }

  1316.             }

  1317.             

  1318.         }

  1319. 

  1320.     // Capture only

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

  1322.     

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

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

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

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

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

  1328.                 return -1;

  1329.             }

  1330.         }

  1331.         

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

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

  1334.             return -1;

  1335.         }

  1336.         

  1337.         if (fHogged) {

  1338.             if (!TakeHogAux(fDeviceID, true)) {

  1339.                 jack_error("Cannot take hog mode for capture device");

  1340.             }

  1341.         }

  1342. 

  1343.     // Playback only

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

  1345.     

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

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

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

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

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

  1351.                 return -1;

  1352.             }

  1353.         }

  1354.         

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

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

  1357.             return -1;

  1358.         }

  1359.         

  1360.         if (fHogged) {

  1361.             if (!TakeHogAux(fDeviceID, false)) {

  1362.                 jack_error("Cannot take hog mode for playback device");

  1363.             }

  1364.             if (ac3_encoding) {

  1365.                 fDigitalPlayback = IsDigitalDevice(fDeviceID);

  1366.             }

  1367.         }

  1368. 

  1369.     // Use default driver in duplex mode

  1370.     } else {

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

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

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

  1374. 

  1375.             // Creates aggregate device

  1376.             AudioDeviceID captureID = -1;

  1377.             AudioDeviceID playbackID = -1;

  1378.             

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

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

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

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

  1383.                     return -1;

  1384.                 }

  1385.             }

  1386. 

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

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

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

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

  1391.                     return -1;

  1392.                 }

  1393.             }

  1394. 

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

  1396.                 return -1;

  1397.             }

  1398. 

  1399.             GetDeviceNameFromID(captureID, fCaptureUID);

  1400.             GetDeviceNameFromID(playbackID, fPlaybackUID);

  1401.             

  1402.             if (fHogged) {

  1403.                 if (!TakeHogAux(captureID, true)) {

  1404.                     jack_error("Cannot take hog mode for capture device");

  1405.                 }

  1406.                 if (!TakeHogAux(playbackID, false)) {

  1407.                     jack_error("Cannot take hog mode for playback device");

  1408.                 }

  1409.                 if (ac3_encoding) {

  1410.                     fDigitalPlayback = IsDigitalDevice(playbackID);

  1411.                 }

  1412.             }

  1413.         }

  1414.     }

  1415.      

  1416.     return 0;

  1417. }

  1418. 

  1419. /*

  1420. Return the max possible input channels in in_maxChannels and output channels in out_maxChannels.

  1421. */

  1422. int JackCoreAudioDriver::SetupChannels(bool capturing, bool playing, int& inchannels, int& outchannels, int& in_maxChannels, int& out_maxChannels, bool strict)

  1423. {

  1424.     OSStatus err = noErr;

  1425.     

  1426.     jack_log("JackCoreAudioDriver::SetupChannels : fDeviceID = %d", fDeviceID);

  1427. 

  1428.     if (capturing) {

  1429.         err = GetTotalChannels(fDeviceID, in_maxChannels, true);

  1430.         if (err != noErr) {

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

  1432.             printError(err);

  1433.             return -1;

  1434.         } else {

  1435.             jack_log("JackCoreAudioDriver::SetupChannels : max input channels : %d", in_maxChannels);

  1436.         }

  1437.     }

  1438. 

  1439.     if (playing) {

  1440.         err = GetTotalChannels(fDeviceID, out_maxChannels, false);

  1441.         if (err != noErr) {

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

  1443.             printError(err);

  1444.             return -1;

  1445.         } else {

  1446.             jack_log("JackCoreAudioDriver::SetupChannels : max output channels : %d", out_maxChannels);

  1447.         }

  1448.     }

  1449. 

  1450.     if (inchannels > in_maxChannels) {

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

  1452.         if (strict) {

  1453.             return -1;

  1454.         }

  1455.     }

  1456. 

  1457.     if (outchannels > out_maxChannels) {

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

  1459.         if (strict) {

  1460.             return -1;

  1461.         }

  1462.     }

  1463. 

  1464.     if (inchannels == -1) {

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

  1466.         inchannels = in_maxChannels;

  1467.     }

  1468. 

  1469.     if (outchannels == -1) {

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

  1471.         outchannels = out_maxChannels;

  1472.     }

  1473. 

  1474.     return 0;

  1475. }

  1476. 

  1477. int JackCoreAudioDriver::SetupBufferSize(jack_nframes_t buffer_size)

  1478. {

  1479.     // Setting buffer size

  1480.     OSStatus err = noErr;

  1481.     UInt32 tmp_buffer_size = buffer_size;

  1482.     UInt32 outSize = sizeof(UInt32);

  1483.  

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

  1485.     if (err != noErr) {

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

  1487.         printError(err);

  1488.         return -1;

  1489.     } else {

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

  1491.     }

  1492. 

  1493.     // If needed, set new buffer size

  1494.     if (buffer_size != tmp_buffer_size) {

  1495.         tmp_buffer_size = buffer_size;

  1496. 

  1497.         // To get BS change notification

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

  1499.         if (err != noErr) {

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

  1501.             printError(err);

  1502.             return -1;

  1503.         }

  1504. 

  1505.         // Waiting for BS change notification

  1506.         int count = 0;

  1507.         fState = false;

  1508. 

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

  1510.         if (err != noErr) {

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

  1512.             printError(err);

  1513.             goto error;

  1514.         }

  1515. 

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

  1517.             usleep(100000);

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

  1519.         }

  1520. 

  1521.         if (count >= WAIT_NOTIFICATION_COUNTER) {

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

  1523.             goto error;

  1524.         }

  1525. 

  1526.         // Check new buffer size

  1527.         outSize = sizeof(UInt32);

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

  1529.         if (err != noErr) {

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

  1531.             printError(err);

  1532.         } else {

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

  1534.         }

  1535. 

  1536.         // Remove BS change notification

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

  1538.     }

  1539. 

  1540.     return 0;

  1541. 

  1542. error:

  1543. 

  1544.     // Remove BS change notification

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

  1546.     return -1;

  1547. }

  1548. 

  1549. int JackCoreAudioDriver::SetupSampleRate(jack_nframes_t sample_rate)

  1550. {

  1551.     return SetupSampleRateAux(fDeviceID, sample_rate);

  1552. }

  1553. 

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

  1555. {

  1556.     OSStatus err = noErr;

  1557.     UInt32 outSize;

  1558.     Float64 tmp_sample_rate;

  1559. 

  1560.     // Get sample rate

  1561.     outSize =  sizeof(Float64);

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

  1563.     if (err != noErr) {

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

  1565.         printError(err);

  1566.         return -1;

  1567.     } else {

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

  1569.     }

  1570. 

  1571.     // If needed, set new sample rate

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

  1573.         tmp_sample_rate = (Float64)sample_rate;

  1574. 

  1575.         // To get SR change notification

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

  1577.         if (err != noErr) {

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

  1579.             printError(err);

  1580.             return -1;

  1581.         }

  1582. 

  1583.         // Waiting for SR change notification

  1584.         int count = 0;

  1585.         fState = false;

  1586. 

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

  1588.         if (err != noErr) {

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

  1590.             printError(err);

  1591.             goto error;

  1592.         }

  1593. 

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

  1595.             usleep(100000);

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

  1597.         }

  1598. 

  1599.         if (count >= WAIT_NOTIFICATION_COUNTER) {

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

  1601.             goto error;

  1602.         }

  1603. 

  1604.         // Check new sample rate

  1605.         outSize = sizeof(Float64);

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

  1607.         if (err != noErr) {

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

  1609.             printError(err);

  1610.         } else {

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

  1612.         }

  1613. 

  1614.         // Remove SR change notification

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

  1616.     }

  1617. 

  1618.     return 0;

  1619. 

  1620. error:

  1621. 

  1622.     // Remove SR change notification

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

  1624.     return -1;

  1625. }

  1626. 

  1627. int JackCoreAudioDriver::OpenAUHAL(bool capturing,

  1628.                                    bool playing,

  1629.                                    int inchannels,

  1630.                                    int outchannels,

  1631.                                    int in_maxChannels,

  1632.                                    int out_maxChannels,

  1633.                                    const vector<int>& chan_in_list,

  1634.                                    const vector<int>& chan_out_list,

  1635.                                    jack_nframes_t buffer_size,

  1636.                                    jack_nframes_t sample_rate)

  1637. {

  1638.     ComponentResult err1;

  1639.     UInt32 enableIO;

  1640.     AudioStreamBasicDescription srcFormat, dstFormat;

  1641.     AudioDeviceID currAudioDeviceID;

  1642.     UInt32 size;

  1643. 

  1644.     jack_log("JackCoreAudioDriver::OpenAUHAL : capturing = %d playing = %d inchannels = %d outchannels = %d in_maxChannels = %d out_maxChannels = %d chan_in_list = %d chan_out_list = %d",

  1645.         capturing, playing, inchannels, outchannels, in_maxChannels, out_maxChannels, chan_in_list.size(), chan_out_list.size());

  1646. 

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

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

  1649.         return -1;

  1650.     }

  1651.     

  1652.     // AUHAL

  1653. #ifdef MAC_OS_X_VERSION_10_5

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

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

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

  1657.     if (err1 != noErr) {

  1658.         jack_error("Error calling OpenAComponent");

  1659.         printError(err1);

  1660.         goto error;

  1661.     }

  1662. #else 

  1663.     AudioComponentDescription cd = {kAudioUnitType_Output, kAudioUnitSubType_HALOutput, kAudioUnitManufacturer_Apple, 0, 0};

  1664.     AudioComponent HALOutput = AudioComponentFindNext(NULL, &cd);

  1665.     err1 = AudioComponentInstanceNew(HALOutput, &fAUHAL);

  1666.     if (err1 != noErr) {

  1667.         jack_error("Error calling AudioComponentInstanceNew");

  1668.         printError(err1);

  1669.         goto error;

  1670.     }

  1671. #endif

  1672. 

  1673.     err1 = AudioUnitInitialize(fAUHAL);

  1674.     if (err1 != noErr) {

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

  1676.         printError(err1);

  1677.         goto error;

  1678.     }

  1679.     

  1680.     // Start I/O

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

  1682.         enableIO = 1;

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

  1684.     } else {

  1685.         enableIO = 0;

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

  1687.     }

  1688. 

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

  1690.     if (err1 != noErr) {

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

  1692.         printError(err1);

  1693.         goto error;

  1694.     }

  1695. 

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

  1697.         enableIO = 1;

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

  1699.     } else {

  1700.         enableIO = 0;

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

  1702.     }

  1703. 

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

  1705.     if (err1 != noErr) {

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

  1707.         printError(err1);

  1708.         goto error;

  1709.     }

  1710. 

  1711.     size = sizeof(AudioDeviceID);

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

  1713.     if (err1 != noErr) {

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

  1715.         printError(err1);

  1716.         goto error;

  1717.     } else {

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

  1719.     }

  1720. 

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

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

  1723.     if (err1 != noErr) {

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

  1725.         printError(err1);

  1726.         goto error;

  1727.     }

  1728. 

  1729.     // Set buffer size

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

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

  1732.         if (err1 != noErr) {

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

  1734.             printError(err1);

  1735.             goto error;

  1736.         }

  1737.     }

  1738. 

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

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

  1741.         if (err1 != noErr) {

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

  1743.             printError(err1);

  1744.             goto error;

  1745.         }

  1746.     }

  1747. 

  1748.     // Setup input channel map

  1749.     if (capturing && inchannels > 0 && inchannels <= in_maxChannels) {

  1750.         SInt32 chanArr[in_maxChannels];

  1751.         for (int i = 0; i < in_maxChannels; i++) {

  1752.             chanArr[i] = -1;

  1753.         }

  1754.         // Explicit mapping

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

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

  1757.                 int chan = chan_in_list[i];

  1758.                 if (chan < in_maxChannels) {

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

  1760.                     chanArr[chan] = i;

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

  1762.                 } else {

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

  1764.                     goto error;

  1765.                 }

  1766.             }

  1767.         } else {

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

  1769.                 chanArr[i] = i;

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

  1771.             }

  1772.         }

  1773. 

  1774.         AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_ChannelMap , kAudioUnitScope_Input, 1, chanArr, sizeof(SInt32) * in_maxChannels);

  1775.         if (err1 != noErr) {

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

  1777.             printError(err1);

  1778.             goto error;

  1779.         }

  1780.     }

  1781. 

  1782.     // Setup output channel map

  1783.     if (playing && outchannels > 0 && outchannels <= out_maxChannels) {

  1784.         SInt32 chanArr[out_maxChannels];

  1785.         for (int i = 0;	i < out_maxChannels; i++) {

  1786.             chanArr[i] = -1;

  1787.         }

  1788.         // Explicit mapping

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

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

  1791.                 int chan = chan_out_list[i];

  1792.                 if (chan < out_maxChannels) {

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

  1794.                     chanArr[chan] = i;

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

  1796.                 } else {

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

  1798.                     goto error;

  1799.                 }

  1800.             }

  1801.         } else {

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

  1803.                 chanArr[i] = i;

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

  1805.             }

  1806.         }

  1807. 

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

  1809.         if (err1 != noErr) {

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

  1811.             printError(err1);

  1812.             goto error;

  1813.         }

  1814.     }

  1815. 

  1816.     // Setup stream converters

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

  1818. 

  1819.         size = sizeof(AudioStreamBasicDescription);

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

  1821.         if (err1 != noErr) {

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

  1823.             printError(err1);

  1824.             goto error;

  1825.         }

  1826.         PrintStreamDesc(&srcFormat);

  1827. 

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

  1829.         srcFormat.mSampleRate = sample_rate;

  1830.         srcFormat.mFormatID = kAudioFormatLinearPCM;

  1831.         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1832.         srcFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1833.         srcFormat.mFramesPerPacket = 1;

  1834.         srcFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1835.         srcFormat.mChannelsPerFrame = inchannels;

  1836.         srcFormat.mBitsPerChannel = 32;

  1837.         PrintStreamDesc(&srcFormat);

  1838. 

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

  1840.         if (err1 != noErr) {

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

  1842.             printError(err1);

  1843.             goto error;

  1844.         }

  1845.     }

  1846. 

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

  1848. 

  1849.         size = sizeof(AudioStreamBasicDescription);

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

  1851.         if (err1 != noErr) {

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

  1853.             printError(err1);

  1854.             goto error;

  1855.         }

  1856.         PrintStreamDesc(&dstFormat);

  1857. 

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

  1859.         dstFormat.mSampleRate = sample_rate;

  1860.         dstFormat.mFormatID = kAudioFormatLinearPCM;

  1861.         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1862.         dstFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1863.         dstFormat.mFramesPerPacket = 1;

  1864.         dstFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1865.         dstFormat.mChannelsPerFrame = outchannels;

  1866.         dstFormat.mBitsPerChannel = 32;

  1867.         PrintStreamDesc(&dstFormat);

  1868. 

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

  1870.         if (err1 != noErr) {

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

  1872.             printError(err1);

  1873.             goto error;

  1874.         }

  1875.     }

  1876. 

  1877.     // Setup callbacks

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

  1879.         AURenderCallbackStruct output;

  1880.         output.inputProc = Render;

  1881.         output.inputProcRefCon = this;

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

  1883.         if (err1 != noErr) {

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

  1885.             printError(err1);

  1886.             goto error;

  1887.         }

  1888.     } else {

  1889.         AURenderCallbackStruct output;

  1890.         output.inputProc = Render;

  1891.         output.inputProcRefCon = this;

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

  1893.         if (err1 != noErr) {

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

  1895.             printError(err1);

  1896.             goto error;

  1897.         }

  1898.     }

  1899. 

  1900.     return 0;

  1901. 

  1902. error:

  1903.     CloseAUHAL();

  1904.     return -1;

  1905. }

  1906. 

  1907. int JackCoreAudioDriver::SetupBuffers(int inchannels)

  1908. {

  1909.     // Prepare buffers

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

  1911.     fJackInputData->mNumberBuffers = inchannels;

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

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

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

  1915.     }

  1916.     return 0;

  1917. }

  1918. 

  1919. void JackCoreAudioDriver::DisposeBuffers()

  1920. {

  1921.     if (fJackInputData) {

  1922.         free(fJackInputData);

  1923.         fJackInputData = 0;

  1924.     }

  1925. }

  1926. 

  1927. void JackCoreAudioDriver::CloseAUHAL()

  1928. {

  1929.     AudioOutputUnitStop(fAUHAL);

  1930.     AudioUnitUninitialize(fAUHAL);

  1931.     CloseComponent(fAUHAL);

  1932. }

  1933. 

  1934. int JackCoreAudioDriver::AddListeners()

  1935. {

  1936.     OSStatus err = noErr;

  1937. 

  1938.     // Add listeners

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

  1940.     if (err != noErr) {

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

  1942.         printError(err);

  1943.         return -1;

  1944.     }

  1945. 

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

  1947.     if (err != noErr) {

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

  1949.         printError(err);

  1950.         return -1;

  1951.     }

  1952. 

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

  1954.     if (err != noErr) {

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

  1956.         printError(err);

  1957.         return -1;

  1958.     }

  1959. 

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

  1961.     if (err != noErr) {

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

  1963.         printError(err);

  1964.         return -1;

  1965.     }

  1966. 

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

  1968.     if (err != noErr) {

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

  1970.         printError(err);

  1971.         return -1;

  1972.     }

  1973. 

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

  1975.     if (err != noErr) {

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

  1977.         printError(err);

  1978.         return -1;

  1979.     }

  1980. 

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

  1982.     if (err != noErr) {

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

  1984.         printError(err);

  1985.         return -1;

  1986.     }

  1987. 

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

  1989.     if (err != noErr) {

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

  1991.         printError(err);

  1992.         return -1;

  1993.     }

  1994. 

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

  1996.         UInt32 outSize = sizeof(float);

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

  1998.         if (err != noErr) {

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

  2000.             printError(err);

  2001.         }

  2002.     }

  2003. 

  2004.     return 0;

  2005. }

  2006. 

  2007. void JackCoreAudioDriver::RemoveListeners()

  2008. {

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

  2010.     AudioHardwareRemovePropertyListener(kAudioHardwarePropertyDevices, AudioHardwareNotificationCallback);

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

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

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

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

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

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

  2017. }

  2018. 

  2019. int JackCoreAudioDriver::Open(jack_nframes_t buffer_size,

  2020.                               jack_nframes_t sample_rate,

  2021.                               bool capturing,

  2022.                               bool playing,

  2023.                               int inchannels,

  2024.                               int outchannels,

  2025.                               const char* chan_in_list,

  2026.                               const char* chan_out_list,

  2027.                               bool monitor,

  2028.                               const char* capture_driver_uid,

  2029.                               const char* playback_driver_uid,

  2030.                               jack_nframes_t capture_latency,

  2031.                               jack_nframes_t playback_latency,

  2032.                               int async_output_latency,

  2033.                               int computation_grain,

  2034.                               bool hogged,

  2035.                               bool clock_drift,

  2036.                               bool ac3_encoding,

  2037.                               int ac3_bitrate,

  2038.                               bool ac3_lfe)

  2039. {

  2040.     int in_maxChannels = 0;

  2041.     int out_maxChannels = 0;

  2042.     char capture_driver_name[256];

  2043.     char playback_driver_name[256];

  2044. 

  2045.     fCaptureLatency = capture_latency;

  2046.     fPlaybackLatency = playback_latency;

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

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

  2049.     fHogged = hogged;

  2050.     fClockDriftCompensate = clock_drift;

  2051. 

  2052.     SInt32 major;

  2053.     SInt32 minor;

  2054.     Gestalt(gestaltSystemVersionMajor, &major);

  2055.     Gestalt(gestaltSystemVersionMinor, &minor);

  2056. 

  2057.     vector<int> parsed_chan_in_list;

  2058.     vector<int> parsed_chan_out_list;

  2059.    

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

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

  2062.         CFRunLoopRef theRunLoop = NULL;

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

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

  2065.         if (osErr != noErr) {

  2066.             jack_error("Open kAudioHardwarePropertyRunLoop error");

  2067.             printError(osErr);

  2068.         }

  2069.     }

  2070.   

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

  2072.         goto error;

  2073.     }

  2074. 

  2075.     // Generic JackAudioDriver Open

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

  2077.                             capturing, playing,

  2078.                             inchannels, outchannels,

  2079.                             monitor,

  2080.                             capture_driver_name,

  2081.                             playback_driver_name,

  2082.                             capture_latency,

  2083.                             playback_latency) != 0) {

  2084.         goto error;

  2085.     }

  2086. 

  2087.     if (SetupChannels(capturing, playing, inchannels, outchannels, in_maxChannels, out_maxChannels, !ac3_encoding) < 0) {

  2088.         goto error;

  2089.     }

  2090.     

  2091.     ParseChannelList(chan_in_list, parsed_chan_in_list, in_maxChannels);

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

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

  2094.         inchannels = parsed_chan_in_list.size();

  2095.     }

  2096. 

  2097.     ParseChannelList(chan_out_list, parsed_chan_out_list, out_maxChannels);

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

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

  2100.         outchannels = parsed_chan_out_list.size();

  2101.     }  

  2102. 

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

  2104.         goto error;

  2105.     }

  2106. 

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

  2108.         goto error;

  2109.     }

  2110.     

  2111.     if (ac3_encoding) {

  2112.           

  2113.         if (!fDigitalPlayback) {

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

  2115.             goto error;

  2116.         }

  2117.         

  2118.         JackAC3EncoderParams params;

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

  2120.         params.bitrate = ac3_bitrate;

  2121.         params.channels = outchannels;

  2122.         params.sample_rate = sample_rate;

  2123.         params.lfe = ac3_lfe;

  2124.         fAC3Encoder = new JackAC3Encoder(params);

  2125.         

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

  2127.             jack_error("Cannot allocate or init AC3 encoder");

  2128.             goto error;

  2129.         }

  2130.         

  2131.         // Setup AC3 channel number

  2132.         fPlaybackChannels = outchannels;

  2133.         if (ac3_lfe) {

  2134.             fPlaybackChannels++;

  2135.         }

  2136.         

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

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

  2139.             goto error;

  2140.         }

  2141.         

  2142.         // Force real output channel number to 2

  2143.         outchannels = out_maxChannels = 2;

  2144.         

  2145.     } else {

  2146.         fPlaybackChannels = outchannels;

  2147.     }

  2148.     

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

  2150.     fCaptureChannels = inchannels;

  2151. 

  2152.     if (OpenAUHAL(capturing, playing, inchannels, outchannels, in_maxChannels, out_maxChannels, parsed_chan_in_list, parsed_chan_out_list, buffer_size, sample_rate) < 0) {

  2153.         goto error;

  2154.     }

  2155. 

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

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

  2158.             goto error;

  2159.         }

  2160.     }

  2161. 

  2162.     if (AddListeners() < 0) {

  2163.         goto error;

  2164.     }

  2165.   

  2166.     return noErr;

  2167. 

  2168. error:

  2169.     Close();

  2170.     return -1;

  2171. }

  2172. 

  2173. int JackCoreAudioDriver::Close()

  2174. {

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

  2176. 

  2177.     // Generic audio driver close

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

  2179. 

  2180.     RemoveListeners();

  2181.     DisposeBuffers();

  2182.     CloseAUHAL();

  2183.     DestroyAggregateDevice();

  2184.     return res;

  2185. }

  2186. 

  2187. void JackCoreAudioDriver::UpdateLatencies()

  2188. {

  2189.     UInt32 size;

  2190.     OSStatus err;

  2191.     jack_latency_range_t input_range;

  2192.     jack_latency_range_t output_range;

  2193.     jack_latency_range_t monitor_range;

  2194. 

  2195.     // Get Input latency

  2196.     size = sizeof(UInt32);

  2197.     UInt32 value1 = 0;

  2198.     UInt32 value2 = 0;

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

  2200.     if (err != noErr) {

  2201.         jack_error("AudioDeviceGetProperty kAudioDevicePropertyLatency error");

  2202.     }

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

  2204.     if (err != noErr) {

  2205.         jack_error("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");

  2206.     }

  2207. 

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

  2209. 

  2210.     // Get input stream latencies

  2211.     vector<int> input_latencies;

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

  2213. 

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

  2215.         if (err != noErr) {

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

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

  2218.         }

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

  2220.     }

  2221. 

  2222.     // Get Output latency

  2223.     size = sizeof(UInt32);

  2224.     value1 = 0;

  2225.     value2 = 0;

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

  2227.     if (err != noErr) {

  2228.         jack_error("AudioDeviceGetProperty kAudioDevicePropertyLatency error");

  2229.     }

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

  2231.     if (err != noErr) {

  2232.         jack_error("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");

  2233.     }

  2234. 

  2235.     // Get output stream latencies

  2236.     vector<int> output_latencies;

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

  2238. 

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

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

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

  2242. 

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

  2244.         if (err != noErr) {

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

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

  2247.         }

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

  2249. 

  2250.         // Monitor port

  2251.         if (fWithMonitorPorts) {

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

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

  2254.         }

  2255.     }

  2256. }

  2257. 

  2258. int JackCoreAudioDriver::Attach()

  2259. {

  2260.     OSStatus err;

  2261.     JackPort* port;

  2262.     jack_port_id_t port_index;

  2263.     UInt32 size;

  2264.     Boolean isWritable;

  2265.     char channel_name[64];

  2266.     char name[REAL_JACK_PORT_NAME_SIZE];

  2267.     char alias[REAL_JACK_PORT_NAME_SIZE];

  2268. 

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

  2270. 

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

  2272. 

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

  2274.         if (err != noErr) {

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

  2276.         }

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

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

  2279.             if (err != noErr) {

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

  2281.             }

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

  2283.         } else {

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

  2285.         }

  2286. 

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

  2288. 

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

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

  2291.             return -1;

  2292.         }

  2293. 

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

  2295.         port->SetAlias(alias);

  2296.         fCapturePortList[i] = port_index;

  2297.     }

  2298. 

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

  2300. 

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

  2302.         if (err != noErr) {

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

  2304.         }

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

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

  2307.             if (err != noErr) {

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

  2309.             }

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

  2311.         } else {

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

  2313.         }

  2314. 

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

  2316. 

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

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

  2319.             return -1;

  2320.         }

  2321. 

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

  2323.         port->SetAlias(alias);

  2324.         fPlaybackPortList[i] = port_index;

  2325. 

  2326.         // Monitor ports

  2327.         if (fWithMonitorPorts) {

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

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

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

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

  2332.                 return -1;

  2333.             } else {

  2334.                 fMonitorPortList[i] = port_index;

  2335.             }

  2336.         }

  2337.     }

  2338.     

  2339.     if (fAC3Encoder) {

  2340.         // Setup specific AC3 channels names

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

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

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

  2344.             port->SetAlias(alias);

  2345.         }

  2346.     }

  2347. 

  2348.     UpdateLatencies();

  2349. 

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

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

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

  2353.     }

  2354. 

  2355.     return 0;

  2356. }

  2357. 

  2358. int JackCoreAudioDriver::Start()

  2359. {

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

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

  2362. 

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

  2364.         fState = false;

  2365.         int count = 0;

  2366. 

  2367.         if (AudioOutputUnitStart(fAUHAL) == noErr) {

  2368. 

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

  2370.                 usleep(100000);

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

  2372.             }

  2373. 

  2374.             if (count < WAIT_COUNTER) {

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

  2376.                 return 0;

  2377.             }

  2378. 

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

  2380.         }

  2381.         JackAudioDriver::Stop();

  2382.     }

  2383.     return -1;

  2384. }

  2385. 

  2386. int JackCoreAudioDriver::Stop()

  2387. {

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

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

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

  2391.         res = -1;

  2392.     }

  2393.     return res;

  2394. }

  2395. 

  2396. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  2397. {

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

  2399.         return -1;

  2400.     }

  2401. 

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

  2403. 

  2404.     // CoreAudio specific

  2405.     UpdateLatencies();

  2406. 

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

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

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

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

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

  2412.     }

  2413. 

  2414.     return 0;

  2415. }

  2416. 

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

  2418. {

  2419.     pid_t hog_pid;

  2420.     UInt32 propSize = sizeof(hog_pid);

  2421.     

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

  2423.     if (err) {

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

  2425.         printError(err);

  2426.     }

  2427.     

  2428.     jack_log("JackCoreAudioDriver::TakeHogAux : deviceID = %d", deviceID);

  2429. 

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

  2431.         hog_pid = getpid();

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

  2433.         if (err != noErr) {

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

  2435.             return false;

  2436.         }

  2437.     }

  2438. 

  2439.     return true;

  2440. }

  2441. 

  2442. bool JackCoreAudioDriver::TakeHog()

  2443. {

  2444.     OSStatus err = noErr;

  2445.     AudioObjectID sub_device[32];

  2446.     UInt32 outSize = sizeof(sub_device);

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

  2448. 

  2449.     if (err != noErr) {

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

  2451.         return TakeHogAux(fDeviceID, true);

  2452.     } else {

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

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

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

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

  2457.                 return false;

  2458.             }

  2459.         }

  2460.         return true;

  2461.     }

  2462. }

  2463. 

  2464. bool JackCoreAudioDriver::IsAggregateDevice(AudioDeviceID device)

  2465. {

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

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

  2468. 

  2469.     if (err != noErr) {

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

  2471.         return false;

  2472.     } else {

  2473.         return (deviceType == kAudioDeviceTransportTypeAggregate);

  2474.     }

  2475. }

  2476. 

  2477. 

  2478. } // end of namespace

  2479. 

  2480. 

  2481. #ifdef __cplusplus

  2482. extern "C"

  2483. {

  2484. #endif

  2485. 

  2486.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor()

  2487.     {

  2488.         jack_driver_desc_t * desc;

  2489.         jack_driver_desc_filler_t filler;

  2490.         jack_driver_param_value_t value;

  2491. 

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

  2493. 

  2494.         value.i = -1;

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

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

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

  2498. 

  2499.         value.str[0] = 0;

  2500.         jack_driver_descriptor_add_parameter(desc, &filler, "input-list", 'n', JackDriverParamString, &value, NULL, "Input channel list for channel mapping", "List of input channel number to be opened (syntax like : \"0 3 2\")");

  2501.         jack_driver_descriptor_add_parameter(desc, &filler, "output-list", 'N', JackDriverParamString, &value, NULL, "Output channel list for channel mapping", "List of output channel number to be opened (syntax like : \"0 3 2\")");

  2502. 

  2503.         value.str[0] = 0;

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

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

  2506. 

  2507.         value.i  = 0;

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

  2509.         

  2510. #ifndef __ppc__

  2511.         value.i  = 0;

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

  2513.         

  2514.         value.i  = 448;

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

  2516.        

  2517.         value.i  = 0;

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

  2519. #endif

  2520.         value.i  = true;

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

  2522. 

  2523.         value.ui  = 44100U;

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

  2525. 

  2526.         value.ui  = 256U;

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

  2528. 

  2529.         value.str[0] = 0;

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

  2531. 

  2532.         value.ui  = 0;

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

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

  2535. 

  2536.         value.i  = false;

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

  2538. 

  2539.         value.i  = false;

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

  2541. 

  2542.         value.ui  = 100;

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

  2544. 

  2545.         value.ui  = 100;

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

  2547. 

  2548.         value.i = false;

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

  2550. 

  2551.         return desc;

  2552.     }

  2553. 

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

  2555.     {

  2556.         jack_nframes_t srate = 44100;

  2557.         jack_nframes_t frames_per_interrupt = 256;

  2558.         bool capture = false;

  2559.         bool playback = false;

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

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

  2562.         const char* chan_in_list = "";

  2563.         const char* chan_out_list = "";

  2564.         bool monitor = false;

  2565.         const char* capture_driver_uid = "";

  2566.         const char* playback_driver_uid = "";

  2567.         const JSList *node;

  2568.         const jack_driver_param_t *param;

  2569.         jack_nframes_t systemic_input_latency = 0;

  2570.         jack_nframes_t systemic_output_latency = 0;

  2571.         int async_output_latency = 100;

  2572.         int computation_grain = -1;

  2573.         bool hogged = false;

  2574.         bool clock_drift = false;

  2575.         bool ac3_encoding = false;

  2576.         int ac3_bitrate = 448;

  2577.         bool ac3_lfe = false;

  2578. 

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

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

  2581. 

  2582.             switch (param->character) {

  2583. 

  2584.                 case 'd':

  2585.                     capture_driver_uid = param->value.str;

  2586.                     playback_driver_uid = param->value.str;

  2587.                     break;

  2588. 

  2589.                 case 'D':

  2590.                     capture = true;

  2591.                     playback = true;

  2592.                     break;

  2593. 

  2594.                 case 'c':

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

  2596.                     break;

  2597. 

  2598.                 case 'i':

  2599.                     chan_in = param->value.i;

  2600.                     break;

  2601. 

  2602.                 case 'o':

  2603.                     chan_out = param->value.i;

  2604.                     break;

  2605. 

  2606.                 case 'n':

  2607.                     chan_in_list = param->value.str;

  2608.                     break;

  2609. 

  2610.                 case 'N':

  2611.                     chan_out_list = param->value.str;

  2612.                     break;

  2613. 

  2614.                 case 'C':

  2615.                     capture = true;

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

  2617.                         capture_driver_uid = param->value.str;

  2618.                     }

  2619.                     break;

  2620. 

  2621.                 case 'P':

  2622.                     playback = true;

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

  2624.                         playback_driver_uid = param->value.str;

  2625.                     }

  2626.                     break;

  2627. 

  2628.                 case 'm':

  2629.                     monitor = param->value.i;

  2630.                     break;

  2631.                     

  2632.             #ifndef __ppc__            

  2633.                 case 'a':

  2634.                     ac3_encoding = param->value.i;

  2635.                     break;

  2636.                      

  2637.                 case 'b':

  2638.                     ac3_bitrate = param->value.i;

  2639.                     break;

  2640.                     

  2641.                 case 'f':

  2642.                     ac3_lfe = param->value.i;

  2643.                     break;

  2644.             #endif

  2645. 

  2646.                 case 'r':

  2647.                     srate = param->value.ui;

  2648.                     break;

  2649. 

  2650.                 case 'p':

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

  2652.                     break;

  2653. 

  2654.                 case 'I':

  2655.                     systemic_input_latency = param->value.ui;

  2656.                     break;

  2657. 

  2658.                 case 'O':

  2659.                     systemic_output_latency = param->value.ui;

  2660.                     break;

  2661. 

  2662.                 case 'l':

  2663.                     Jack::DisplayDeviceNames();

  2664.                     // Stops the server in this case

  2665.                     return NULL;

  2666. 

  2667.                 case 'H':

  2668.                     hogged = true;

  2669.                     break;

  2670. 

  2671.                 case 'L':

  2672.                     async_output_latency = param->value.ui;

  2673.                     break;

  2674. 

  2675.                 case 'G':

  2676.                     computation_grain = param->value.ui;

  2677.                     break;

  2678. 

  2679.                 case 's':

  2680.                     clock_drift = true;

  2681.                     break;

  2682.             }

  2683.         }

  2684. 

  2685.         /* duplex is the default */

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

  2687.             capture = true;

  2688.             playback = true;

  2689.         }

  2690. 

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

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

  2693.         }

  2694. 

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

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

  2697.         }

  2698. 

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

  2700.         if (driver->Open(frames_per_interrupt,

  2701.                         srate, capture,

  2702.                         playback, chan_in,

  2703.                         chan_out, chan_in_list,

  2704.                         chan_out_list, monitor,

  2705.                         capture_driver_uid,

  2706.                         playback_driver_uid,

  2707.                         systemic_input_latency,

  2708.                         systemic_output_latency,

  2709.                         async_output_latency,

  2710.                         computation_grain,

  2711.                         hogged, clock_drift, 

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

  2713.             return driver;

  2714.         } else {

  2715.             delete driver;

  2716.             return NULL;

  2717.         }

  2718.     }

  2719. 

  2720. #ifdef __cplusplus

  2721. }

  2722. #endif

  2723.