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

2701 lines
105KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2004-2008 Grame

  3. 

  4. This program is free software; you can redistribute it and/or modify

  5. it under the terms of the GNU General Public License as published by

  6. the Free Software Foundation; either version 2 of the License, or

  7. (at your option) any later version.

  8. 

  9. This program is distributed in the hope that it will be useful,

  10. but WITHOUT ANY WARRANTY; without even the implied warranty of

  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  12. GNU General Public License for more details.

  13. 

  14. You should have received a copy of the GNU General Public License

  15. along with this program; if not, write to the Free Software

  16. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  17. 

  18. */

  19. 

  20. #include "JackCoreAudioDriver.h"

  21. #include "JackEngineControl.h"

  22. #include "JackMachThread.h"

  23. #include "JackGraphManager.h"

  24. #include "JackError.h"

  25. #include "JackClientControl.h"

  26. #include "JackDriverLoader.h"

  27. #include "JackGlobals.h"

  28. #include "JackTools.h"

  29. #include "JackLockedEngine.h"

  30. #include "JackAC3Encoder.h"

  31. 

  32. #include <sstream>

  33. #include <iostream>

  34. #include <CoreServices/CoreServices.h>

  35. #include <CoreFoundation/CFNumber.h>

  36. 

  37. namespace Jack

  38. {

  39. 

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

  41. {

  42.     UInt32 __4CC_number = (c);

  43.     char __4CC_string[5];

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

  45.     __4CC_string[4] = 0;

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

  47. }

  48. 

  49. static void PrintStreamDesc(AudioStreamBasicDescription *inDesc)

  50. {

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

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

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

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

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

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

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

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

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

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

  61. }

  62. 

  63. static void printError(OSStatus err)

  64. {

  65.     switch (err) {

  66.         case kAudioHardwareNoError:

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

  68.             break;

  69.         case kAudioConverterErr_FormatNotSupported:

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

  71.             break;

  72.         case kAudioConverterErr_OperationNotSupported:

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

  74.             break;

  75.         case kAudioConverterErr_PropertyNotSupported:

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

  77.             break;

  78.         case kAudioConverterErr_InvalidInputSize:

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

  80.             break;

  81.         case kAudioConverterErr_InvalidOutputSize:

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

  83.             break;

  84.         case kAudioConverterErr_UnspecifiedError:

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

  86.             break;

  87.         case kAudioConverterErr_BadPropertySizeError:

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

  89.             break;

  90.         case kAudioConverterErr_RequiresPacketDescriptionsError:

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

  92.             break;

  93.         case kAudioConverterErr_InputSampleRateOutOfRange:

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

  95.             break;

  96.         case kAudioConverterErr_OutputSampleRateOutOfRange:

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

  98.             break;

  99.         case kAudioHardwareNotRunningError:

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

  101.             break;

  102.         case kAudioHardwareUnknownPropertyError:

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

  104.             break;

  105.         case kAudioHardwareIllegalOperationError:

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

  107.             break;

  108.         case kAudioHardwareBadDeviceError:

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

  110.             break;

  111.         case kAudioHardwareBadStreamError:

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

  113.             break;

  114.         case kAudioDeviceUnsupportedFormatError:

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

  116.             break;

  117.         case kAudioDevicePermissionsError:

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

  119.             break;

  120.         case kAudioHardwareBadObjectError:

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

  122.             break;

  123.         case kAudioHardwareUnsupportedOperationError:

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

  125.             break;

  126.         default:

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

  128.             break;

  129.     }

  130. }

  131. 

  132. static bool CheckAvailableDeviceName(const char* device_name, AudioDeviceID* device_id)

  133. {

  134.     UInt32 size;

  135.     Boolean isWritable;

  136.     int i, deviceNum;

  137.     OSStatus err;

  138. 

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

  140.     if (err != noErr) {

  141.         return false;

  142.     }

  143. 

  144.     deviceNum = size / sizeof(AudioDeviceID);

  145.     AudioDeviceID devices[deviceNum];

  146. 

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

  148.     if (err != noErr) {

  149.         return false;

  150.     }

  151. 

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

  153.         char device_name_aux[256];

  154. 

  155.         size = 256;

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

  157.         if (err != noErr) {

  158.             return false;

  159.         }

  160. 

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

  162.             *device_id = devices[i];

  163.             return true;

  164.         }

  165. 

  166.     }

  167. 

  168.     return false;

  169. }

  170. 

  171. static bool CheckAvailableDevice(AudioDeviceID device_id)

  172. {

  173.     UInt32 size;

  174.     Boolean isWritable;

  175.     int i, deviceNum;

  176.     OSStatus err;

  177. 

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

  179.     if (err != noErr) {

  180.         return false;

  181.     }

  182. 

  183.     deviceNum = size / sizeof(AudioDeviceID);

  184.     AudioDeviceID devices[deviceNum];

  185. 

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

  187.     if (err != noErr) {

  188.         return false;

  189.     }

  190. 

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

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

  193.             return true;

  194.         }

  195.     }

  196. 

  197.     return false;

  198. }

  199. 

  200. 

  201. static OSStatus DisplayDeviceNames()

  202. {

  203.     UInt32 size;

  204.     Boolean isWritable;

  205.     int i, deviceNum;

  206.     OSStatus err;

  207.     CFStringRef UIname;

  208. 

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

  210.     if (err != noErr) {

  211.         return err;

  212.     }

  213. 

  214.     deviceNum = size / sizeof(AudioDeviceID);

  215.     AudioDeviceID devices[deviceNum];

  216. 

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

  218.     if (err != noErr) {

  219.         return err;

  220.     }

  221. 

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

  223.         char device_name[256];

  224.         char internal_name[256];

  225. 

  226.         size = sizeof(CFStringRef);

  227.         UIname = NULL;

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

  229.         if (err == noErr) {

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

  231.         } else {

  232.             goto error;

  233.         }

  234. 

  235.         size = 256;

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

  237.         if (err != noErr) {

  238.             return err;

  239.         }

  240. 

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

  242.     }

  243. 

  244.     return noErr;

  245. 

  246. error:

  247.     if (UIname != NULL) {

  248.         CFRelease(UIname);

  249.     }

  250.     return err;

  251. }

  252. 

  253. static CFStringRef GetDeviceName(AudioDeviceID id)

  254. {

  255.     UInt32 size = sizeof(CFStringRef);

  256.     CFStringRef UIname;

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

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

  259. }

  260. 

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

  262. {

  263.     stringstream ss(list);

  264.     string token;

  265.     int chan;

  266.   

  267.     while (ss >> token) {

  268.         istringstream ins;

  269.         ins.str(token);

  270.         ins >> chan;

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

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

  273.         } else {

  274.             result.push_back(chan);

  275.         }

  276.     }

  277. }

  278. 

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

  280.                                      AudioUnitRenderActionFlags* ioActionFlags,

  281.                                      const AudioTimeStamp* inTimeStamp,

  282.                                      UInt32 inBusNumber,

  283.                                      UInt32 inNumberFrames,

  284.                                      AudioBufferList* ioData)

  285. {

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

  287.     driver->fActionFags = ioActionFlags;

  288.     driver->fCurrentTime = inTimeStamp;

  289.     driver->fDriverOutputData = ioData;

  290. 

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

  292.     if (set_threaded_log_function()) {

  293. 

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

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

  296. 

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

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

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

  300.         }

  301.     }

  302. 

  303.     // Signal waiting start function...

  304.     driver->fState = true;

  305. 

  306.     driver->CycleTakeBeginTime();

  307. 

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

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

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

  311.         driver->Stop();

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

  313.         return kAudioHardwareUnsupportedOperationError;

  314.     } else {

  315.         return noErr;

  316.     }

  317. }

  318. 

  319. int JackCoreAudioDriver::Read()

  320. {

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

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

  323.     } else {

  324.         return 0;

  325.     }

  326. }

  327. 

  328. int JackCoreAudioDriver::Write()

  329. {

  330.     if (fAC3Encoder) {

  331.     

  332.         // AC3 encoding and SPDIF write

  333.         jack_default_audio_sample_t* AC3_inputs[MAX_AC3_CHANNELS];

  334.         jack_default_audio_sample_t* AC3_outputs[2];

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

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

  337.             // If not connected, clear the buffer

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

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

  340.             }

  341.         }

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

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

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

  345.         

  346.     } else {

  347.        

  348.         // Standard write

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

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

  351.                 jack_default_audio_sample_t* buffer = GetOutputBuffer(i);

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

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

  354.                 // Monitor ports

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

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

  357.                 }

  358.             } else {

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

  360.             }

  361.         }

  362.     }

  363.     return 0;

  364. }

  365. 

  366. OSStatus JackCoreAudioDriver::SRNotificationCallback(AudioDeviceID inDevice,

  367.                                                     UInt32 inChannel,

  368.                                                     Boolean	isInput,

  369.                                                     AudioDevicePropertyID inPropertyID,

  370.                                                     void* inClientData)

  371. {

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

  373. 

  374.     switch (inPropertyID) {

  375. 

  376.         case kAudioDevicePropertyNominalSampleRate: {

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

  378.             // Check new sample rate

  379.             Float64 tmp_sample_rate;

  380.             UInt32 outSize = sizeof(Float64);

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

  382.             if (err != noErr) {

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

  384.                 printError(err);

  385.             } else {

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

  387.             }

  388.             driver->fState = true;

  389.             break;

  390.         }

  391.     }

  392. 

  393.     return noErr;

  394. }

  395. 

  396. OSStatus JackCoreAudioDriver::BSNotificationCallback(AudioDeviceID inDevice,

  397.                                                      UInt32 inChannel,

  398.                                                      Boolean isInput,

  399.                                                      AudioDevicePropertyID inPropertyID,

  400.                                                      void* inClientData)

  401. {

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

  403. 

  404.     switch (inPropertyID) {

  405. 

  406.         case kAudioDevicePropertyBufferFrameSize: {

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

  408.             // Check new buffer size

  409.             UInt32 tmp_buffer_size;

  410.             UInt32 outSize = sizeof(UInt32);

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

  412.             if (err != noErr) {

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

  414.                 printError(err);

  415.             } else {

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

  417.             }

  418.             driver->fState = true;

  419.             break;

  420.         }

  421.     }

  422. 

  423.     return noErr;

  424. }

  425. 

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

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

  428. {

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

  430. 

  431.     switch (inPropertyID) {

  432. 

  433.         case kAudioHardwarePropertyDevices: {

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

  435.             DisplayDeviceNames();

  436.             AudioDeviceID captureID, playbackID;

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

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

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

  440. 

  441.             }

  442.             break;

  443.         }

  444.     }

  445. 

  446.     return noErr;

  447. }

  448. 

  449. OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,

  450.                                                         UInt32 inChannel,

  451.                                                         Boolean	isInput,

  452.                                                         AudioDevicePropertyID inPropertyID,

  453.                                                         void* inClientData)

  454. {

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

  456. 

  457.     switch (inPropertyID) {

  458. 

  459.         case kAudioDevicePropertyDeviceIsRunning: {

  460.             UInt32 isrunning = 0;

  461.             UInt32 outsize = sizeof(UInt32);

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

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

  464.             }

  465.             break;

  466.         }

  467. 

  468.         case kAudioDevicePropertyDeviceIsAlive: {

  469.             UInt32 isalive = 0;

  470.             UInt32 outsize = sizeof(UInt32);

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

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

  473.             }

  474.             break;

  475.         }

  476. 

  477.         case kAudioDevicePropertyDeviceHasChanged: {

  478.             UInt32 hachanged = 0;

  479.             UInt32 outsize = sizeof(UInt32);

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

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

  482.             }

  483.             break;

  484.         }

  485. 

  486.         case kAudioDeviceProcessorOverload: {

  487.             jack_error("DeviceNotificationCallback kAudioDeviceProcessorOverload");

  488.             jack_time_t cur_time = GetMicroSeconds();

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

  490.             break;

  491.         }

  492. 

  493.         case kAudioDevicePropertyStreamConfiguration: {

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

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

  496.             driver->CloseAUHAL();

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

  498.             return kAudioHardwareUnsupportedOperationError;

  499.         }

  500. 

  501.         case kAudioDevicePropertyNominalSampleRate: {

  502.             Float64 sample_rate = 0;

  503.             UInt32 outsize = sizeof(Float64);

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

  505.             if (err != noErr) {

  506.                 return kAudioHardwareUnsupportedOperationError;

  507.             }

  508. 

  509.             char device_name[256];

  510.             const char* digidesign_name = "Digidesign";

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

  512. 

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

  514. 

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

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

  517. 

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

  519. 

  520.                     // Set sample rate again...

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

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

  523.                     if (err != noErr) {

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

  525.                         printError(err);

  526.                     } else {

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

  528.                     }

  529. 

  530.                     // Check new sample rate again...

  531.                     outsize = sizeof(Float64);

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

  533.                     if (err != noErr) {

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

  535.                         printError(err);

  536.                     } else {

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

  538.                     }

  539.                     return noErr;

  540. 

  541.                 } else {

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

  543.                     driver->CloseAUHAL();

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

  545.                     return kAudioHardwareUnsupportedOperationError;

  546.                 }

  547.             }

  548.         }

  549. 

  550.     }

  551.     return noErr;

  552. }

  553. 

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

  555. {

  556.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  559. 

  560.     if (inIUD == NULL) {

  561.         return kAudioHardwareUnspecifiedError;

  562.     } else {

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

  564.         CFRelease(inIUD);

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

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

  567.     }

  568. }

  569. 

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

  571. {

  572.     OSStatus res;

  573.     UInt32 theSize = sizeof(UInt32);

  574.     AudioDeviceID inDefault;

  575.     AudioDeviceID outDefault;

  576. 

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

  578.         return res;

  579.     }

  580. 

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

  582.         return res;

  583.     }

  584. 

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

  586. 

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

  588.     if (inDefault != outDefault) {

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

  590.         return kAudioHardwareBadDeviceError;

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

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

  593.         return kAudioHardwareBadDeviceError;

  594.     } else {

  595.         *id = inDefault;

  596.         return noErr;

  597.     }

  598. }

  599. 

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

  601. {

  602.     OSStatus res;

  603.     UInt32 theSize = sizeof(UInt32);

  604.     AudioDeviceID inDefault;

  605. 

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

  607.         return res;

  608.     }

  609. 

  610.     if (inDefault == 0) {

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

  612.         return -1;

  613.     }

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

  615.     *id = inDefault;

  616.     return noErr;

  617. }

  618. 

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

  620. {

  621.     OSStatus res;

  622.     UInt32 theSize = sizeof(UInt32);

  623.     AudioDeviceID outDefault;

  624. 

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

  626.         return res;

  627.     }

  628. 

  629.     if (outDefault == 0) {

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

  631.         return -1;

  632.     }

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

  634.     *id = outDefault;

  635.     return noErr;

  636. }

  637. 

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

  639. {

  640.     UInt32 size = 256;

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

  642. }

  643. 

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

  645. {

  646.     OSStatus err = noErr;

  647.     UInt32 outSize;

  648.     Boolean	outWritable;

  649. 

  650.     channelCount = 0;

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

  652.     if (err == noErr) {

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

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

  655.         AudioBufferList bufferList[stream_count];

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

  657.         if (err == noErr) {

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

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

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

  661.             }

  662.         }

  663.     }

  664.     return err;

  665. }

  666. 

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

  668. {

  669.     OSStatus err = noErr;

  670.     UInt32 outSize1, outSize2, outSize3;

  671.     Boolean	outWritable;

  672. 

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

  674.     if (err == noErr) {

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

  676.         AudioStreamID streamIDs[stream_count];

  677.         AudioBufferList bufferList[stream_count];

  678.         UInt32 streamLatency;

  679.         outSize2 = sizeof(UInt32);

  680. 

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

  682.         if (err != noErr) {

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

  684.             return err;

  685.         }

  686. 

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

  688.         if (err != noErr) {

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

  690.             return err;

  691.         }

  692. 

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

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

  695.             if (err != noErr) {

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

  697.                 return err;

  698.             }

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

  700.             if (err != noErr) {

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

  702.                 return err;

  703.             }

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

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

  706.                 latencies.push_back(streamLatency);

  707.             }

  708.         }

  709.     }

  710.     return err;

  711. }

  712. 

  713. bool JackCoreAudioDriver::IsDigitalDevice(AudioDeviceID device)

  714. {

  715.     OSStatus err = noErr;

  716.     UInt32 outSize1;

  717.     bool is_digital = false;

  718.     

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

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

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

  722.     if (err != noErr) {

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

  724.         return false;

  725.     }

  726.     

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

  728.     AudioStreamID streamIDs[stream_count];

  729.     

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

  731. 

  732.     if (err != noErr) {

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

  734.         return false;

  735.     }

  736.     

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

  738.      

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

  740.    

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

  742.         int  format_num = 0;

  743.     

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

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

  746.         

  747.         if (err != noErr) {

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

  749.             return false;

  750.         }

  751. 

  752.         format_num = outSize1 / sizeof(AudioStreamRangedDescription);

  753.         AudioStreamRangedDescription format_list[format_num];

  754.       

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

  756.          

  757.         if (err != noErr) {

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

  759.             return false;

  760.         }

  761.    

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

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

  764.         

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

  766.             

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

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

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

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

  771.             {

  772.                 is_digital = true;

  773.                 break;

  774.             }

  775.         }

  776.     }

  777.        

  778.     return is_digital;

  779. }

  780. 

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

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

  783.         fAC3Encoder(NULL),

  784.         fJackInputData(NULL),

  785.         fDriverOutputData(NULL),

  786.         fPluginID(0),

  787.         fState(false),

  788.         fHogged(false),

  789.         fIOUsage(1.f),

  790.         fComputationGrain(-1.f),

  791.         fClockDriftCompensate(false),

  792.         fDigitalPlayback(false)

  793. {}

  794. 

  795. JackCoreAudioDriver::~JackCoreAudioDriver()

  796. {

  797.     delete fAC3Encoder;

  798. }

  799. 

  800. OSStatus JackCoreAudioDriver::DestroyAggregateDevice()

  801. {

  802.     OSStatus osErr = noErr;

  803.     AudioObjectPropertyAddress pluginAOPA;

  804.     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;

  805.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  806.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  807.     UInt32 outDataSize;

  808. 

  809.     if (fPluginID > 0) {

  810. 

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

  812.         if (osErr != noErr) {

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

  814.             printError(osErr);

  815.             return osErr;

  816.         }

  817. 

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

  819.         if (osErr != noErr) {

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

  821.             printError(osErr);

  822.             return osErr;

  823.         }

  824. 

  825.     }

  826. 

  827.     return noErr;

  828. }

  829. 

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

  831. {

  832.     OSStatus err = noErr;

  833.     AudioObjectID sub_device[32];

  834.     UInt32 outSize = sizeof(sub_device);

  835. 

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

  837.     vector<AudioDeviceID> captureDeviceIDArray;

  838. 

  839.     if (err != noErr) {

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

  841.         captureDeviceIDArray.push_back(captureDeviceID);

  842.     } else {

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

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

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

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

  847.         }

  848.     }

  849. 

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

  851.     vector<AudioDeviceID> playbackDeviceIDArray;

  852. 

  853.     if (err != noErr) {

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

  855.         playbackDeviceIDArray.push_back(playbackDeviceID);

  856.     } else {

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

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

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

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

  861.         }

  862.     }

  863. 

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

  865. }

  866. 

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

  868. {

  869.     OSStatus osErr = noErr;

  870.     UInt32 outSize;

  871.     Boolean outWritable;

  872. 

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

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

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

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

  877.     UInt32 theQualifierDataSize = sizeof(AudioObjectID);

  878.     AudioClassID inClass = kAudioSubDeviceClassID;

  879.     void* theQualifierData = &inClass;

  880.     UInt32 subDevicesNum = 0;

  881. 

  882.     //---------------------------------------------------------------------------

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

  884.     //---------------------------------------------------------------------------

  885.     UInt32 keptclockdomain = 0;

  886.     UInt32 clockdomain = 0;

  887.     outSize = sizeof(UInt32);

  888.     bool need_clock_drift_compensation = false;

  889. 

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

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

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

  893.         } else  {

  894.             // Check clock domain

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

  896.             if (osErr != 0) {

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

  898.                 printError(osErr);

  899.             } else {

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

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

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

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

  904.                     need_clock_drift_compensation = true;

  905.                 }

  906.             }

  907.         }

  908.     }

  909. 

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

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

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

  913.         } else {

  914.             // Check clock domain

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

  916.             if (osErr != 0) {

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

  918.                 printError(osErr);

  919.             } else {

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

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

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

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

  924.                     need_clock_drift_compensation = true;

  925.                 }

  926.             }

  927.         }

  928.     }

  929. 

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

  931.     if (keptclockdomain == 0) {

  932.         need_clock_drift_compensation = true;

  933.     }

  934. 

  935.     //---------------------------------------------------------------------------

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

  937.     //---------------------------------------------------------------------------

  938. 

  939.     char device_name[256];

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

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

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

  943.     }

  944. 

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

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

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

  948.     }

  949. 

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

  951.     if (osErr != noErr) {

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

  953.         printError(osErr);

  954.         return osErr;

  955.     }

  956. 

  957.     AudioValueTranslation pluginAVT;

  958. 

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

  960. 

  961.     pluginAVT.mInputData = &inBundleRef;

  962.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  963.     pluginAVT.mOutputData = &fPluginID;

  964.     pluginAVT.mOutputDataSize = sizeof(fPluginID);

  965. 

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

  967.     if (osErr != noErr) {

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

  969.         printError(osErr);

  970.         return osErr;

  971.     }

  972. 

  973.     //-------------------------------------------------

  974.     // Create a CFDictionary for our aggregate device

  975.     //-------------------------------------------------

  976. 

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

  978. 

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

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

  981. 

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

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

  984. 

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

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

  987. 

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

  989.     int value = 1;

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

  991. 

  992.     SInt32 system;

  993.     Gestalt(gestaltSystemVersion, &system);

  994. 

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

  996. 

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

  998.     if (system < 0x00001054) {

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

  1000.     } else {

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

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

  1003.     }

  1004. 

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

  1006.     CFMutableArrayRef subDevicesArrayClock = NULL;

  1007. 

  1008.     /*

  1009.     if (fClockDriftCompensate) {

  1010.         if (need_clock_drift_compensation) {

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

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

  1013. 

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

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

  1016.                 if (UID) {

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

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

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

  1020.                     //CFRelease(UID);

  1021.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  1022.                 }

  1023.             }

  1024. 

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

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

  1027.                 if (UID) {

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

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

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

  1031.                     //CFRelease(UID);

  1032.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  1033.                 }

  1034.             }

  1035. 

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

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

  1038.         } else {

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

  1040.         }

  1041.     }

  1042.     */

  1043. 

  1044.     //-------------------------------------------------

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

  1046.     //-------------------------------------------------

  1047. 

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

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

  1050. 

  1051.     vector<CFStringRef> captureDeviceUID;

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

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

  1054.         if (ref == NULL) {

  1055.             return -1;

  1056.         }

  1057.         captureDeviceUID.push_back(ref);

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

  1059.         CFArrayAppendValue(subDevicesArray, ref);

  1060.    }

  1061. 

  1062.     vector<CFStringRef> playbackDeviceUID;

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

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

  1065.         if (ref == NULL) {

  1066.             return -1;

  1067.         }

  1068.         playbackDeviceUID.push_back(ref);

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

  1070.         CFArrayAppendValue(subDevicesArray, ref);

  1071.     }

  1072. 

  1073.     //-----------------------------------------------------------------------

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

  1075.     //-----------------------------------------------------------------------

  1076. 

  1077.     AudioObjectPropertyAddress pluginAOPA;

  1078.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  1079.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1080.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1081.     UInt32 outDataSize;

  1082. 

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

  1084.     if (osErr != noErr) {

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

  1086.         printError(osErr);

  1087.         goto error;

  1088.     }

  1089. 

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

  1091.     if (osErr != noErr) {

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

  1093.         printError(osErr);

  1094.         goto error;

  1095.     }

  1096. 

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

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

  1099.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1100. 

  1101.     //-------------------------

  1102.     // Set the sub-device list

  1103.     //-------------------------

  1104. 

  1105.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  1106.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1107.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1108.     outDataSize = sizeof(CFMutableArrayRef);

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

  1110.     if (osErr != noErr) {

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

  1112.         printError(osErr);

  1113.         goto error;

  1114.     }

  1115. 

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

  1117.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1118. 

  1119.     //-----------------------

  1120.     // Set the master device

  1121.     //-----------------------

  1122. 

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

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

  1125.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  1126.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1127.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1128.     outDataSize = sizeof(CFStringRef);

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

  1130.     if (osErr != noErr) {

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

  1132.         printError(osErr);

  1133.         goto error;

  1134.     }

  1135. 

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

  1137.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1138. 

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

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

  1141. 

  1142.     if (fClockDriftCompensate) {

  1143.         if (need_clock_drift_compensation) {

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

  1145. 

  1146.             // Get the property data size

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

  1148.             if (osErr != noErr) {

  1149.                 jack_error("CreateAggregateDevice kAudioObjectPropertyOwnedObjects error");

  1150.                 printError(osErr);

  1151.             }

  1152. 

  1153.             //	Calculate the number of object IDs

  1154.             subDevicesNum = outSize / sizeof(AudioObjectID);

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

  1156.             AudioObjectID subDevices[subDevicesNum];

  1157.             outSize = sizeof(subDevices);

  1158. 

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

  1160.             if (osErr != noErr) {

  1161.                 jack_error("CreateAggregateDevice kAudioObjectPropertyOwnedObjects error");

  1162.                 printError(osErr);

  1163.             }

  1164. 

  1165.             // Set kAudioSubDevicePropertyDriftCompensation property...

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

  1167.                 UInt32 theDriftCompensationValue = 1;

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

  1169.                 if (osErr != noErr) {

  1170.                     jack_error("CreateAggregateDevice kAudioSubDevicePropertyDriftCompensation error");

  1171.                     printError(osErr);

  1172.                 }

  1173.             }

  1174.         } else {

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

  1176.         }

  1177.     }

  1178. 

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

  1180.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1181. 

  1182.     //----------

  1183.     // Clean up

  1184.     //----------

  1185. 

  1186.     // release the private AD key

  1187.     CFRelease(AggregateDeviceNumberRef);

  1188. 

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

  1190.     CFRelease(aggDeviceDict);

  1191.     CFRelease(subDevicesArray);

  1192. 

  1193.     if (subDevicesArrayClock) {

  1194.         CFRelease(subDevicesArrayClock);

  1195.     }

  1196. 

  1197.     // release the device UID

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

  1199.         CFRelease(captureDeviceUID[i]);

  1200.     }

  1201. 

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

  1203.         CFRelease(playbackDeviceUID[i]);

  1204.     }

  1205. 

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

  1207.     return noErr;

  1208. 

  1209. error:

  1210.     DestroyAggregateDevice();

  1211.     return -1;

  1212. }

  1213. 

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

  1215.                                       const char* playback_driver_uid,

  1216.                                       char* capture_driver_name,

  1217.                                       char* playback_driver_name,

  1218.                                       jack_nframes_t samplerate,

  1219.                                       bool ac3_encoding)

  1220. {

  1221.     capture_driver_name[0] = 0;

  1222.     playback_driver_name[0] = 0;

  1223. 

  1224.     // Duplex

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

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

  1227. 

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

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

  1230. 

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

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

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

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

  1235.                     return -1;

  1236.                 }

  1237.             }

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

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

  1240.                 return -1;

  1241.             }

  1242.             

  1243.             if (fHogged) {

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

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

  1246.                 } 

  1247.                 if (ac3_encoding) {

  1248.                     fDigitalPlayback = IsDigitalDevice(fDeviceID);

  1249.                 }

  1250.             }

  1251. 

  1252.         } else {

  1253. 

  1254.             // Creates aggregate device

  1255.             AudioDeviceID captureID = -1;

  1256.             AudioDeviceID playbackID = -1;

  1257.     

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

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

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

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

  1262.                     return -1;

  1263.                 }

  1264.             }

  1265. 

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

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

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

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

  1270.                     return -1;

  1271.                 }

  1272.             }

  1273. 

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

  1275.                 return -1;

  1276.             }

  1277. 

  1278.             GetDeviceNameFromID(captureID, fCaptureUID);

  1279.             GetDeviceNameFromID(playbackID, fPlaybackUID);

  1280.             

  1281.             if (fHogged) {

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

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

  1284.                 }

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

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

  1287.                 }

  1288.                 if (ac3_encoding) {

  1289.                     fDigitalPlayback = IsDigitalDevice(playbackID);

  1290.                 }

  1291.             }

  1292.             

  1293.         }

  1294. 

  1295.     // Capture only

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

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

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

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

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

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

  1302.                 return -1;

  1303.             }

  1304.         }

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

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

  1307.             return -1;

  1308.         }

  1309.         

  1310.         if (fHogged) {

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

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

  1313.             }

  1314.         }

  1315. 

  1316.     // Playback only

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

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

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

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

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

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

  1323.                 return -1;

  1324.             }

  1325.         }

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

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

  1328.             return -1;

  1329.         }

  1330.         

  1331.         if (fHogged) {

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

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

  1334.             }

  1335.             if (ac3_encoding) {

  1336.                 fDigitalPlayback = IsDigitalDevice(fDeviceID);

  1337.             }

  1338.         }

  1339. 

  1340.     // Use default driver in duplex mode

  1341.     } else {

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

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

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

  1345. 

  1346.             // Creates aggregate device

  1347.             AudioDeviceID captureID = -1;

  1348.             AudioDeviceID playbackID = -1;

  1349.             

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

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

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

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

  1354.                     return -1;

  1355.                 }

  1356.             }

  1357. 

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

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

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

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

  1362.                     return -1;

  1363.                 }

  1364.             }

  1365. 

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

  1367.                 return -1;

  1368.             }

  1369. 

  1370.             GetDeviceNameFromID(captureID, fCaptureUID);

  1371.             GetDeviceNameFromID(playbackID, fPlaybackUID);

  1372.             

  1373.             if (fHogged) {

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

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

  1376.                 }

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

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

  1379.                 }

  1380.                 if (ac3_encoding) {

  1381.                     fDigitalPlayback = IsDigitalDevice(playbackID);

  1382.                 }

  1383.             }

  1384.         }

  1385.     }

  1386.      

  1387.     return 0;

  1388. }

  1389. 

  1390. /*

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

  1392. */

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

  1394. {

  1395.     OSStatus err = noErr;

  1396. 

  1397.     if (capturing) {

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

  1399.         if (err != noErr) {

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

  1401.             printError(err);

  1402.             return -1;

  1403.         } else {

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

  1405.         }

  1406.     }

  1407. 

  1408.     if (playing) {

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

  1410.         if (err != noErr) {

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

  1412.             printError(err);

  1413.             return -1;

  1414.         } else {

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

  1416.         }

  1417.     }

  1418. 

  1419.     if (inchannels > in_maxChannels) {

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

  1421.         if (strict) {

  1422.             return -1;

  1423.         }

  1424.     }

  1425. 

  1426.     if (outchannels > out_maxChannels) {

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

  1428.         if (strict) {

  1429.             return -1;

  1430.         }

  1431.     }

  1432. 

  1433.     if (inchannels == -1) {

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

  1435.         inchannels = in_maxChannels;

  1436.     }

  1437. 

  1438.     if (outchannels == -1) {

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

  1440.         outchannels = out_maxChannels;

  1441.     }

  1442. 

  1443.     return 0;

  1444. }

  1445. 

  1446. int JackCoreAudioDriver::SetupBufferSize(jack_nframes_t buffer_size)

  1447. {

  1448.     // Setting buffer size

  1449.     OSStatus err = noErr;

  1450.     UInt32 tmp_buffer_size = buffer_size;

  1451.     UInt32 outSize = sizeof(UInt32);

  1452. 

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

  1454.     if (err != noErr) {

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

  1456.         printError(err);

  1457.         return -1;

  1458.     } else {

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

  1460.     }

  1461. 

  1462.     // If needed, set new buffer size

  1463.     if (buffer_size != tmp_buffer_size) {

  1464.         tmp_buffer_size = buffer_size;

  1465. 

  1466.         // To get BS change notification

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

  1468.         if (err != noErr) {

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

  1470.             printError(err);

  1471.             return -1;

  1472.         }

  1473. 

  1474.         // Waiting for BS change notification

  1475.         int count = 0;

  1476.         fState = false;

  1477. 

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

  1479.         if (err != noErr) {

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

  1481.             printError(err);

  1482.             goto error;

  1483.         }

  1484. 

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

  1486.             usleep(100000);

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

  1488.         }

  1489. 

  1490.         if (count >= WAIT_NOTIFICATION_COUNTER) {

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

  1492.             goto error;

  1493.         }

  1494. 

  1495.         // Check new buffer size

  1496.         outSize = sizeof(UInt32);

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

  1498.         if (err != noErr) {

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

  1500.             printError(err);

  1501.         } else {

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

  1503.         }

  1504. 

  1505.         // Remove BS change notification

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

  1507.     }

  1508. 

  1509.     return 0;

  1510. 

  1511. error:

  1512. 

  1513.     // Remove BS change notification

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

  1515.     return -1;

  1516. }

  1517. 

  1518. int JackCoreAudioDriver::SetupSampleRate(jack_nframes_t sample_rate)

  1519. {

  1520.     return SetupSampleRateAux(fDeviceID, sample_rate);

  1521. }

  1522. 

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

  1524. {

  1525.     OSStatus err = noErr;

  1526.     UInt32 outSize;

  1527.     Float64 tmp_sample_rate;

  1528. 

  1529.     // Get sample rate

  1530.     outSize =  sizeof(Float64);

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

  1532.     if (err != noErr) {

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

  1534.         printError(err);

  1535.         return -1;

  1536.     } else {

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

  1538.     }

  1539. 

  1540.     // If needed, set new sample rate

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

  1542.         tmp_sample_rate = (Float64)sample_rate;

  1543. 

  1544.         // To get SR change notification

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

  1546.         if (err != noErr) {

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

  1548.             printError(err);

  1549.             return -1;

  1550.         }

  1551. 

  1552.         // Waiting for SR change notification

  1553.         int count = 0;

  1554.         fState = false;

  1555. 

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

  1557.         if (err != noErr) {

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

  1559.             printError(err);

  1560.             goto error;

  1561.         }

  1562. 

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

  1564.             usleep(100000);

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

  1566.         }

  1567. 

  1568.         if (count >= WAIT_NOTIFICATION_COUNTER) {

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

  1570.             goto error;

  1571.         }

  1572. 

  1573.         // Check new sample rate

  1574.         outSize = sizeof(Float64);

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

  1576.         if (err != noErr) {

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

  1578.             printError(err);

  1579.         } else {

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

  1581.         }

  1582. 

  1583.         // Remove SR change notification

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

  1585.     }

  1586. 

  1587.     return 0;

  1588. 

  1589. error:

  1590. 

  1591.     // Remove SR change notification

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

  1593.     return -1;

  1594. }

  1595. 

  1596. int JackCoreAudioDriver::OpenAUHAL(bool capturing,

  1597.                                    bool playing,

  1598.                                    int inchannels,

  1599.                                    int outchannels,

  1600.                                    int in_maxChannels,

  1601.                                    int out_maxChannels,

  1602.                                    const vector<int>& chan_in_list,

  1603.                                    const vector<int>& chan_out_list,

  1604.                                    jack_nframes_t buffer_size,

  1605.                                    jack_nframes_t sample_rate)

  1606. {

  1607.     ComponentResult err1;

  1608.     UInt32 enableIO;

  1609.     AudioStreamBasicDescription srcFormat, dstFormat;

  1610.     AudioDeviceID currAudioDeviceID;

  1611.     UInt32 size;

  1612. 

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

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

  1615. 

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

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

  1618.         return -1;

  1619.     }

  1620. 

  1621.     // AUHAL

  1622.     SInt32 major;

  1623.     SInt32 minor;

  1624.     Gestalt(gestaltSystemVersionMajor, &major);

  1625.     Gestalt(gestaltSystemVersionMinor, &minor);

  1626.     

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

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

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

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

  1631.         if (err1 != noErr) {

  1632.             jack_error("Error calling AudioComponentInstanceNew");

  1633.             printError(err1);

  1634.             goto error;

  1635.         }

  1636.     } else {

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

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

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

  1640.         if (err1 != noErr) {

  1641.             jack_error("Error calling OpenAComponent");

  1642.             printError(err1);

  1643.             goto error;

  1644.         }

  1645.     }

  1646. 

  1647.     err1 = AudioUnitInitialize(fAUHAL);

  1648.     if (err1 != noErr) {

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

  1650.         printError(err1);

  1651.         goto error;

  1652.     }

  1653.     

  1654.     // Start I/O

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

  1656.         enableIO = 1;

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

  1658.     } else {

  1659.         enableIO = 0;

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

  1661.     }

  1662. 

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

  1664.     if (err1 != noErr) {

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

  1666.         printError(err1);

  1667.         goto error;

  1668.     }

  1669. 

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

  1671.         enableIO = 1;

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

  1673.     } else {

  1674.         enableIO = 0;

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

  1676.     }

  1677. 

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

  1679.     if (err1 != noErr) {

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

  1681.         printError(err1);

  1682.         goto error;

  1683.     }

  1684. 

  1685.     size = sizeof(AudioDeviceID);

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

  1687.     if (err1 != noErr) {

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

  1689.         printError(err1);

  1690.         goto error;

  1691.     } else {

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

  1693.     }

  1694. 

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

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

  1697.     if (err1 != noErr) {

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

  1699.         printError(err1);

  1700.         goto error;

  1701.     }

  1702. 

  1703.     // Set buffer size

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

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

  1706.         if (err1 != noErr) {

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

  1708.             printError(err1);

  1709.             goto error;

  1710.         }

  1711.     }

  1712. 

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

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

  1715.         if (err1 != noErr) {

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

  1717.             printError(err1);

  1718.             goto error;

  1719.         }

  1720.     }

  1721. 

  1722.     // Setup input channel map

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

  1724.         SInt32 chanArr[in_maxChannels];

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

  1726.             chanArr[i] = -1;

  1727.         }

  1728.         // Explicit mapping

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

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

  1731.                 int chan = chan_in_list[i];

  1732.                 if (chan < out_maxChannels) {

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

  1734.                     chanArr[chan] = i;

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

  1736.                 } else {

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

  1738.                     goto error;

  1739.                 }

  1740.             }

  1741.         } else {

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

  1743.                 chanArr[i] = i;

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

  1745.             }

  1746.         }

  1747. 

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

  1749.         if (err1 != noErr) {

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

  1751.             printError(err1);

  1752.             goto error;

  1753.         }

  1754.     }

  1755. 

  1756.     // Setup output channel map

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

  1758.         SInt32 chanArr[out_maxChannels];

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

  1760.             chanArr[i] = -1;

  1761.         }

  1762.         // Explicit mapping

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

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

  1765.                 int chan = chan_out_list[i];

  1766.                 if (chan < out_maxChannels) {

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

  1768.                     chanArr[chan] = i;

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

  1770.                 } else {

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

  1772.                     goto error;

  1773.                 }

  1774.             }

  1775.         } else {

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

  1777.                 chanArr[i] = i;

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

  1779.             }

  1780.         }

  1781. 

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

  1783.         if (err1 != noErr) {

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

  1785.             printError(err1);

  1786.             goto error;

  1787.         }

  1788.     }

  1789. 

  1790.     // Setup stream converters

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

  1792. 

  1793.         size = sizeof(AudioStreamBasicDescription);

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

  1795.         if (err1 != noErr) {

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

  1797.             printError(err1);

  1798.             goto error;

  1799.         }

  1800.         PrintStreamDesc(&srcFormat);

  1801. 

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

  1803.         srcFormat.mSampleRate = sample_rate;

  1804.         srcFormat.mFormatID = kAudioFormatLinearPCM;

  1805.         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1806.         srcFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1807.         srcFormat.mFramesPerPacket = 1;

  1808.         srcFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1809.         srcFormat.mChannelsPerFrame = inchannels;

  1810.         srcFormat.mBitsPerChannel = 32;

  1811.         PrintStreamDesc(&srcFormat);

  1812. 

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

  1814.         if (err1 != noErr) {

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

  1816.             printError(err1);

  1817.             goto error;

  1818.         }

  1819.     }

  1820. 

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

  1822. 

  1823.         size = sizeof(AudioStreamBasicDescription);

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

  1825.         if (err1 != noErr) {

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

  1827.             printError(err1);

  1828.             goto error;

  1829.         }

  1830.         PrintStreamDesc(&dstFormat);

  1831. 

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

  1833.         dstFormat.mSampleRate = sample_rate;

  1834.         dstFormat.mFormatID = kAudioFormatLinearPCM;

  1835.         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1836.         dstFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1837.         dstFormat.mFramesPerPacket = 1;

  1838.         dstFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1839.         dstFormat.mChannelsPerFrame = outchannels;

  1840.         dstFormat.mBitsPerChannel = 32;

  1841.         PrintStreamDesc(&dstFormat);

  1842. 

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

  1844.         if (err1 != noErr) {

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

  1846.             printError(err1);

  1847.             goto error;

  1848.         }

  1849.     }

  1850. 

  1851.     // Setup callbacks

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

  1853.         AURenderCallbackStruct output;

  1854.         output.inputProc = Render;

  1855.         output.inputProcRefCon = this;

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

  1857.         if (err1 != noErr) {

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

  1859.             printError(err1);

  1860.             goto error;

  1861.         }

  1862.     } else {

  1863.         AURenderCallbackStruct output;

  1864.         output.inputProc = Render;

  1865.         output.inputProcRefCon = this;

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

  1867.         if (err1 != noErr) {

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

  1869.             printError(err1);

  1870.             goto error;

  1871.         }

  1872.     }

  1873. 

  1874.     return 0;

  1875. 

  1876. error:

  1877.     CloseAUHAL();

  1878.     return -1;

  1879. }

  1880. 

  1881. int JackCoreAudioDriver::SetupBuffers(int inchannels)

  1882. {

  1883.     // Prepare buffers

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

  1885.     fJackInputData->mNumberBuffers = inchannels;

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

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

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

  1889.     }

  1890.     return 0;

  1891. }

  1892. 

  1893. void JackCoreAudioDriver::DisposeBuffers()

  1894. {

  1895.     if (fJackInputData) {

  1896.         free(fJackInputData);

  1897.         fJackInputData = 0;

  1898.     }

  1899. }

  1900. 

  1901. void JackCoreAudioDriver::CloseAUHAL()

  1902. {

  1903.     AudioOutputUnitStop(fAUHAL);

  1904.     AudioUnitUninitialize(fAUHAL);

  1905.     CloseComponent(fAUHAL);

  1906. }

  1907. 

  1908. int JackCoreAudioDriver::AddListeners()

  1909. {

  1910.     OSStatus err = noErr;

  1911. 

  1912.     // Add listeners

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

  1914.     if (err != noErr) {

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

  1916.         printError(err);

  1917.         return -1;

  1918.     }

  1919. 

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

  1921.     if (err != noErr) {

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

  1923.         printError(err);

  1924.         return -1;

  1925.     }

  1926. 

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

  1928.     if (err != noErr) {

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

  1930.         printError(err);

  1931.         return -1;

  1932.     }

  1933. 

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

  1935.     if (err != noErr) {

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

  1937.         printError(err);

  1938.         return -1;

  1939.     }

  1940. 

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

  1942.     if (err != noErr) {

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

  1944.         printError(err);

  1945.         return -1;

  1946.     }

  1947. 

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

  1949.     if (err != noErr) {

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

  1951.         printError(err);

  1952.         return -1;

  1953.     }

  1954. 

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

  1956.     if (err != noErr) {

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

  1958.         printError(err);

  1959.         return -1;

  1960.     }

  1961. 

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

  1963.     if (err != noErr) {

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

  1965.         printError(err);

  1966.         return -1;

  1967.     }

  1968. 

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

  1970.         UInt32 outSize = sizeof(float);

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

  1972.         if (err != noErr) {

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

  1974.             printError(err);

  1975.         }

  1976.     }

  1977. 

  1978.     return 0;

  1979. }

  1980. 

  1981. void JackCoreAudioDriver::RemoveListeners()

  1982. {

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

  1984.     AudioHardwareRemovePropertyListener(kAudioHardwarePropertyDevices, AudioHardwareNotificationCallback);

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

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

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

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

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

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

  1991. }

  1992. 

  1993. int JackCoreAudioDriver::Open(jack_nframes_t buffer_size,

  1994.                               jack_nframes_t sample_rate,

  1995.                               bool capturing,

  1996.                               bool playing,

  1997.                               int inchannels,

  1998.                               int outchannels,

  1999.                               const char* chan_in_list,

  2000.                               const char* chan_out_list,

  2001.                               bool monitor,

  2002.                               const char* capture_driver_uid,

  2003.                               const char* playback_driver_uid,

  2004.                               jack_nframes_t capture_latency,

  2005.                               jack_nframes_t playback_latency,

  2006.                               int async_output_latency,

  2007.                               int computation_grain,

  2008.                               bool hogged,

  2009.                               bool clock_drift,

  2010.                               bool ac3_encoding,

  2011.                               int ac3_bitrate,

  2012.                               bool ac3_lfe)

  2013. {

  2014.     int in_maxChannels = 0;

  2015.     int out_maxChannels = 0;

  2016.     char capture_driver_name[256];

  2017.     char playback_driver_name[256];

  2018. 

  2019.     fCaptureLatency = capture_latency;

  2020.     fPlaybackLatency = playback_latency;

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

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

  2023.     fHogged = hogged;

  2024.     fClockDriftCompensate = clock_drift;

  2025. 

  2026.     SInt32 major;

  2027.     SInt32 minor;

  2028.     Gestalt(gestaltSystemVersionMajor, &major);

  2029.     Gestalt(gestaltSystemVersionMinor, &minor);

  2030. 

  2031.     vector<int> parsed_chan_in_list;

  2032.     vector<int> parsed_chan_out_list;

  2033.    

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

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

  2036.         CFRunLoopRef theRunLoop = NULL;

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

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

  2039.         if (osErr != noErr) {

  2040.             jack_error("Open kAudioHardwarePropertyRunLoop error");

  2041.             printError(osErr);

  2042.         }

  2043.     }

  2044.   

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

  2046.         goto error;

  2047.     }

  2048. 

  2049.     // Generic JackAudioDriver Open

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

  2051.                             capturing, playing,

  2052.                             inchannels, outchannels,

  2053.                             monitor,

  2054.                             capture_driver_name,

  2055.                             playback_driver_name,

  2056.                             capture_latency,

  2057.                             playback_latency) != 0) {

  2058.         goto error;

  2059.     }

  2060. 

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

  2062.         goto error;

  2063.     }

  2064.     

  2065.     ParseChannelList(chan_in_list, parsed_chan_in_list, in_maxChannels);

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

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

  2068.         inchannels = parsed_chan_in_list.size();

  2069.     }

  2070. 

  2071.     ParseChannelList(chan_out_list, parsed_chan_out_list, out_maxChannels);

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

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

  2074.         outchannels = parsed_chan_out_list.size();

  2075.     }  

  2076. 

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

  2078.         goto error;

  2079.     }

  2080. 

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

  2082.         goto error;

  2083.     }

  2084.     

  2085.     if (ac3_encoding) {

  2086.           

  2087.         if (!fDigitalPlayback) {

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

  2089.             goto error;

  2090.         }

  2091.         

  2092.         JackAC3EncoderParams params;

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

  2094.         params.bitrate = ac3_bitrate;

  2095.         params.channels = outchannels;

  2096.         params.sample_rate = sample_rate;

  2097.         params.lfe = ac3_lfe;

  2098.         fAC3Encoder = new JackAC3Encoder(params);

  2099.         

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

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

  2102.             goto error;

  2103.         }

  2104.         

  2105.         // Setup AC3 channel number

  2106.         fPlaybackChannels = outchannels;

  2107.         if (ac3_lfe) {

  2108.             fPlaybackChannels++;

  2109.         }

  2110.         

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

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

  2113.             goto error;

  2114.         }

  2115.         

  2116.         // Force real output channel number to 2

  2117.         outchannels = out_maxChannels = 2;

  2118.         

  2119.     } else {

  2120.         fPlaybackChannels = outchannels;

  2121.     }

  2122.     

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

  2124.     fCaptureChannels = inchannels;

  2125. 

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

  2127.         goto error;

  2128.     }

  2129. 

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

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

  2132.             goto error;

  2133.         }

  2134.     }

  2135. 

  2136.     if (AddListeners() < 0) {

  2137.         goto error;

  2138.     }

  2139.   

  2140.     return noErr;

  2141. 

  2142. error:

  2143.     Close();

  2144.     return -1;

  2145. }

  2146. 

  2147. int JackCoreAudioDriver::Close()

  2148. {

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

  2150. 

  2151.     // Generic audio driver close

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

  2153. 

  2154.     RemoveListeners();

  2155.     DisposeBuffers();

  2156.     CloseAUHAL();

  2157.     DestroyAggregateDevice();

  2158.     return res;

  2159. }

  2160. 

  2161. void JackCoreAudioDriver::UpdateLatencies()

  2162. {

  2163.     UInt32 size;

  2164.     OSStatus err;

  2165.     jack_latency_range_t input_range;

  2166.     jack_latency_range_t output_range;

  2167.     jack_latency_range_t monitor_range;

  2168. 

  2169.     // Get Input latency

  2170.     size = sizeof(UInt32);

  2171.     UInt32 value1 = 0;

  2172.     UInt32 value2 = 0;

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

  2174.     if (err != noErr) {

  2175.         jack_error("AudioDeviceGetProperty kAudioDevicePropertyLatency error");

  2176.     }

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

  2178.     if (err != noErr) {

  2179.         jack_error("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");

  2180.     }

  2181. 

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

  2183. 

  2184.     // Get input stream latencies

  2185.     vector<int> input_latencies;

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

  2187. 

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

  2189.         if (err != noErr) {

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

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

  2192.         }

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

  2194.     }

  2195. 

  2196.     // Get Output latency

  2197.     size = sizeof(UInt32);

  2198.     value1 = 0;

  2199.     value2 = 0;

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

  2201.     if (err != noErr) {

  2202.         jack_error("AudioDeviceGetProperty kAudioDevicePropertyLatency error");

  2203.     }

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

  2205.     if (err != noErr) {

  2206.         jack_error("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");

  2207.     }

  2208. 

  2209.     // Get output stream latencies

  2210.     vector<int> output_latencies;

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

  2212. 

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

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

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

  2216. 

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

  2218.         if (err != noErr) {

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

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

  2221.         }

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

  2223. 

  2224.         // Monitor port

  2225.         if (fWithMonitorPorts) {

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

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

  2228.         }

  2229.     }

  2230. }

  2231. 

  2232. int JackCoreAudioDriver::Attach()

  2233. {

  2234.     OSStatus err;

  2235.     JackPort* port;

  2236.     jack_port_id_t port_index;

  2237.     UInt32 size;

  2238.     Boolean isWritable;

  2239.     char channel_name[64];

  2240.     char name[REAL_JACK_PORT_NAME_SIZE];

  2241.     char alias[REAL_JACK_PORT_NAME_SIZE];

  2242. 

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

  2244. 

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

  2246. 

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

  2248.         if (err != noErr) {

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

  2250.         }

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

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

  2253.             if (err != noErr) {

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

  2255.             }

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

  2257.         } else {

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

  2259.         }

  2260. 

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

  2262. 

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

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

  2265.             return -1;

  2266.         }

  2267. 

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

  2269.         port->SetAlias(alias);

  2270.         fCapturePortList[i] = port_index;

  2271.     }

  2272. 

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

  2274. 

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

  2276.         if (err != noErr) {

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

  2278.         }

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

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

  2281.             if (err != noErr) {

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

  2283.             }

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

  2285.         } else {

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

  2287.         }

  2288. 

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

  2290. 

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

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

  2293.             return -1;

  2294.         }

  2295. 

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

  2297.         port->SetAlias(alias);

  2298.         fPlaybackPortList[i] = port_index;

  2299. 

  2300.         // Monitor ports

  2301.         if (fWithMonitorPorts) {

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

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

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

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

  2306.                 return -1;

  2307.             } else {

  2308.                 fMonitorPortList[i] = port_index;

  2309.             }

  2310.         }

  2311.     }

  2312.     

  2313.     if (fAC3Encoder) {

  2314.         // Setup specific AC3 channels names

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

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

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

  2318.             port->SetAlias(alias);

  2319.         }

  2320.     }

  2321. 

  2322.     UpdateLatencies();

  2323. 

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

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

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

  2327.     }

  2328. 

  2329.     return 0;

  2330. }

  2331. 

  2332. int JackCoreAudioDriver::Start()

  2333. {

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

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

  2336. 

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

  2338.         fState = false;

  2339.         int count = 0;

  2340. 

  2341.         OSStatus err = AudioOutputUnitStart(fAUHAL);

  2342.         if (err == noErr) {

  2343. 

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

  2345.                 usleep(100000);

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

  2347.             }

  2348. 

  2349.             if (count < WAIT_COUNTER) {

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

  2351.                 return 0;

  2352.             }

  2353. 

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

  2355.         }

  2356.         JackAudioDriver::Stop();

  2357.     }

  2358.     return -1;

  2359. }

  2360. 

  2361. int JackCoreAudioDriver::Stop()

  2362. {

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

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

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

  2366.         res = -1;

  2367.     }

  2368.     return res;

  2369. }

  2370. 

  2371. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  2372. {

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

  2374.         return -1;

  2375.     }

  2376. 

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

  2378. 

  2379.     // CoreAudio specific

  2380.     UpdateLatencies();

  2381. 

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

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

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

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

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

  2387.     }

  2388. 

  2389.     return 0;

  2390. }

  2391. 

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

  2393. {

  2394.     pid_t hog_pid;

  2395.     OSStatus err;

  2396. 

  2397.     UInt32 propSize = sizeof(hog_pid);

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

  2399.     if (err) {

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

  2401.         printError(err);

  2402.     }

  2403.     

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

  2405. 

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

  2407.         hog_pid = getpid();

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

  2409.         if (err != noErr) {

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

  2411.             return false;

  2412.         }

  2413.     }

  2414. 

  2415.     return true;

  2416. }

  2417. 

  2418. bool JackCoreAudioDriver::TakeHog()

  2419. {

  2420.     OSStatus err = noErr;

  2421.     AudioObjectID sub_device[32];

  2422.     UInt32 outSize = sizeof(sub_device);

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

  2424. 

  2425.     if (err != noErr) {

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

  2427.         return TakeHogAux(fDeviceID, true);

  2428.     } else {

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

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

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

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

  2433.                 return false;

  2434.             }

  2435.         }

  2436.         return true;

  2437.     }

  2438. }

  2439. 

  2440. bool JackCoreAudioDriver::IsAggregateDevice(AudioDeviceID device)

  2441. {

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

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

  2444. 

  2445.     if (err != noErr) {

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

  2447.         return false;

  2448.     } else {

  2449.         return (deviceType == kAudioDeviceTransportTypeAggregate);

  2450.     }

  2451. }

  2452. 

  2453. 

  2454. } // end of namespace

  2455. 

  2456. 

  2457. #ifdef __cplusplus

  2458. extern "C"

  2459. {

  2460. #endif

  2461. 

  2462.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor()

  2463.     {

  2464.         jack_driver_desc_t * desc;

  2465.         jack_driver_desc_filler_t filler;

  2466.         jack_driver_param_value_t value;

  2467. 

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

  2469. 

  2470.         value.i = -1;

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

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

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

  2474. 

  2475.         value.str[0] = 0;

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

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

  2478. 

  2479.         value.str[0] = 0;

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

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

  2482. 

  2483.         value.i  = 0;

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

  2485.         

  2486. #ifndef __ppc__

  2487.         value.i  = 0;

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

  2489.         

  2490.         value.i  = 448;

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

  2492.        

  2493.         value.i  = 0;

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

  2495. #endif

  2496.         value.i  = TRUE;

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

  2498. 

  2499.         value.ui  = 44100U;

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

  2501. 

  2502.         value.ui  = 256U;

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

  2504. 

  2505.         value.str[0] = 0;

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

  2507. 

  2508.         value.ui  = 0;

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

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

  2511. 

  2512.         value.i  = FALSE;

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

  2514. 

  2515.         value.i  = FALSE;

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

  2517. 

  2518.         value.ui  = 100;

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

  2520. 

  2521.         value.ui  = 100;

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

  2523. 

  2524.         value.i = FALSE;

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

  2526. 

  2527.         return desc;

  2528.     }

  2529. 

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

  2531.     {

  2532.         jack_nframes_t srate = 44100;

  2533.         jack_nframes_t frames_per_interrupt = 256;

  2534.         bool capture = false;

  2535.         bool playback = false;

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

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

  2538.         const char* chan_in_list = "";

  2539.         const char* chan_out_list = "";

  2540.         bool monitor = false;

  2541.         const char* capture_driver_uid = "";

  2542.         const char* playback_driver_uid = "";

  2543.         const JSList *node;

  2544.         const jack_driver_param_t *param;

  2545.         jack_nframes_t systemic_input_latency = 0;

  2546.         jack_nframes_t systemic_output_latency = 0;

  2547.         int async_output_latency = 100;

  2548.         int computation_grain = -1;

  2549.         bool hogged = false;

  2550.         bool clock_drift = false;

  2551.         bool ac3_encoding = false;

  2552.         int ac3_bitrate = 448;

  2553.         bool ac3_lfe = false;

  2554. 

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

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

  2557. 

  2558.             switch (param->character) {

  2559. 

  2560.                 case 'd':

  2561.                     capture_driver_uid = param->value.str;

  2562.                     playback_driver_uid = param->value.str;

  2563.                     break;

  2564. 

  2565.                 case 'D':

  2566.                     capture = true;

  2567.                     playback = true;

  2568.                     break;

  2569. 

  2570.                 case 'c':

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

  2572.                     break;

  2573. 

  2574.                 case 'i':

  2575.                     chan_in = param->value.i;

  2576.                     break;

  2577. 

  2578.                 case 'o':

  2579.                     chan_out = param->value.i;

  2580.                     break;

  2581. 

  2582.                 case 'n':

  2583.                     chan_in_list = param->value.str;

  2584.                     break;

  2585. 

  2586.                 case 'N':

  2587.                     chan_out_list = param->value.str;

  2588.                     break;

  2589. 

  2590.                 case 'C':

  2591.                     capture = true;

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

  2593.                         capture_driver_uid = param->value.str;

  2594.                     }

  2595.                     break;

  2596. 

  2597.                 case 'P':

  2598.                     playback = true;

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

  2600.                         playback_driver_uid = param->value.str;

  2601.                     }

  2602.                     break;

  2603. 

  2604.                 case 'm':

  2605.                     monitor = param->value.i;

  2606.                     break;

  2607.                     

  2608.             #ifndef __ppc__            

  2609.                 case 'a':

  2610.                     ac3_encoding = param->value.i;

  2611.                     break;

  2612.                      

  2613.                 case 'b':

  2614.                     ac3_bitrate = param->value.i;

  2615.                     break;

  2616.                     

  2617.                 case 'f':

  2618.                     ac3_lfe = param->value.i;

  2619.                     break;

  2620.             #endif

  2621. 

  2622.                 case 'r':

  2623.                     srate = param->value.ui;

  2624.                     break;

  2625. 

  2626.                 case 'p':

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

  2628.                     break;

  2629. 

  2630.                 case 'I':

  2631.                     systemic_input_latency = param->value.ui;

  2632.                     break;

  2633. 

  2634.                 case 'O':

  2635.                     systemic_output_latency = param->value.ui;

  2636.                     break;

  2637. 

  2638.                 case 'l':

  2639.                     Jack::DisplayDeviceNames();

  2640.                     // Stops the server in this case

  2641.                     return NULL;

  2642. 

  2643.                 case 'H':

  2644.                     hogged = true;

  2645.                     break;

  2646. 

  2647.                 case 'L':

  2648.                     async_output_latency = param->value.ui;

  2649.                     break;

  2650. 

  2651.                 case 'G':

  2652.                     computation_grain = param->value.ui;

  2653.                     break;

  2654. 

  2655.                 case 's':

  2656.                     clock_drift = true;

  2657.                     break;

  2658.             }

  2659.         }

  2660. 

  2661.         /* duplex is the default */

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

  2663.             capture = true;

  2664.             playback = true;

  2665.         }

  2666. 

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

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

  2669.         }

  2670. 

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

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

  2673.         }

  2674. 

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

  2676.         if (driver->Open(frames_per_interrupt,

  2677.                         srate, capture,

  2678.                         playback, chan_in,

  2679.                         chan_out, chan_in_list,

  2680.                         chan_out_list, monitor,

  2681.                         capture_driver_uid,

  2682.                         playback_driver_uid,

  2683.                         systemic_input_latency,

  2684.                         systemic_output_latency,

  2685.                         async_output_latency,

  2686.                         computation_grain,

  2687.                         hogged, clock_drift, 

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

  2689.             return driver;

  2690.         } else {

  2691.             delete driver;

  2692.             return NULL;

  2693.         }

  2694.     }

  2695. 

  2696. #ifdef __cplusplus

  2697. }

  2698. #endif

  2699.