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

2465 lines
96KB
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. 

  31. #include <sstream>

  32. #include <iostream>

  33. #include <CoreServices/CoreServices.h>

  34. #include <CoreFoundation/CFNumber.h>

  35. 

  36. namespace Jack

  37. {

  38. 

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

  40. {

  41.     UInt32 __4CC_number = (c);

  42.     char __4CC_string[5];

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

  44.     __4CC_string[4] = 0;

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

  46. }

  47. 

  48. static void PrintStreamDesc(AudioStreamBasicDescription *inDesc)

  49. {

  50.     jack_log("- - - - - - - - - - - - - - - - - - - -");

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

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

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

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

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

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

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

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

  59.     jack_log("- - - - - - - - - - - - - - - - - - - -");

  60. }

  61. 

  62. static void printError(OSStatus err)

  63. {

  64.     switch (err) {

  65.         case kAudioHardwareNoError:

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

  67.             break;

  68.         case kAudioConverterErr_FormatNotSupported:

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

  70.             break;

  71.         case kAudioConverterErr_OperationNotSupported:

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

  73.             break;

  74.         case kAudioConverterErr_PropertyNotSupported:

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

  76.             break;

  77.         case kAudioConverterErr_InvalidInputSize:

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

  79.             break;

  80.         case kAudioConverterErr_InvalidOutputSize:

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

  82.             break;

  83.         case kAudioConverterErr_UnspecifiedError:

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

  85.             break;

  86.         case kAudioConverterErr_BadPropertySizeError:

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

  88.             break;

  89.         case kAudioConverterErr_RequiresPacketDescriptionsError:

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

  91.             break;

  92.         case kAudioConverterErr_InputSampleRateOutOfRange:

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

  94.             break;

  95.         case kAudioConverterErr_OutputSampleRateOutOfRange:

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

  97.             break;

  98.         case kAudioHardwareNotRunningError:

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

  100.             break;

  101.         case kAudioHardwareUnknownPropertyError:

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

  103.             break;

  104.         case kAudioHardwareIllegalOperationError:

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

  106.             break;

  107.         case kAudioHardwareBadDeviceError:

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

  109.             break;

  110.         case kAudioHardwareBadStreamError:

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

  112.             break;

  113.         case kAudioDeviceUnsupportedFormatError:

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

  115.             break;

  116.         case kAudioDevicePermissionsError:

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

  118.             break;

  119.         case kAudioHardwareBadObjectError:

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

  121.             break;

  122.         case kAudioHardwareUnsupportedOperationError:

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

  124.             break;

  125.         default:

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

  127.             break;

  128.     }

  129. }

  130. 

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

  132. {

  133.     UInt32 size;

  134.     Boolean isWritable;

  135.     int i, deviceNum;

  136.     OSStatus err;

  137. 

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

  139.     if (err != noErr) {

  140.         return false;

  141.     }

  142. 

  143.     deviceNum = size / sizeof(AudioDeviceID);

  144.     AudioDeviceID devices[deviceNum];

  145. 

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

  147.     if (err != noErr) {

  148.         return false;

  149.     }

  150. 

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

  152.         char device_name_aux[256];

  153. 

  154.         size = 256;

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

  156.         if (err != noErr) {

  157.             return false;

  158.         }

  159. 

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

  161.             *device_id = devices[i];

  162.             return true;

  163.         }

  164. 

  165.     }

  166. 

  167.     return false;

  168. }

  169. 

  170. static bool CheckAvailableDevice(AudioDeviceID device_id)

  171. {

  172.     UInt32 size;

  173.     Boolean isWritable;

  174.     int i, deviceNum;

  175.     OSStatus err;

  176. 

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

  178.     if (err != noErr) {

  179.         return false;

  180.     }

  181. 

  182.     deviceNum = size / sizeof(AudioDeviceID);

  183.     AudioDeviceID devices[deviceNum];

  184. 

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

  186.     if (err != noErr) {

  187.         return false;

  188.     }

  189. 

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

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

  192.             return true;

  193.         }

  194. 

  195.     }

  196. 

  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)

  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.         result.push_back(chan);

  272.     }

  273. }

  274. 

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

  276.                                      AudioUnitRenderActionFlags* ioActionFlags,

  277.                                      const AudioTimeStamp* inTimeStamp,

  278.                                      UInt32 inBusNumber,

  279.                                      UInt32 inNumberFrames,

  280.                                      AudioBufferList* ioData)

  281. {

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

  283.     driver->fActionFags = ioActionFlags;

  284.     driver->fCurrentTime = inTimeStamp;

  285.     driver->fDriverOutputData = ioData;

  286. 

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

  288.     if (set_threaded_log_function()) {

  289. 

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

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

  292. 

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

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

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

  296.         }

  297.     }

  298. 

  299.     // Signal waiting start function...

  300.     driver->fState = true;

  301. 

  302.     driver->CycleTakeBeginTime();

  303. 

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

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

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

  307.         driver->Stop();

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

  309.         return kAudioHardwareUnsupportedOperationError;

  310.     } else {

  311.         return noErr;

  312.     }

  313. }

  314. 

  315. int JackCoreAudioDriver::Read()

  316. {

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

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

  319.     } else {

  320.         return 0;

  321.     }

  322. }

  323. 

  324. int JackCoreAudioDriver::Write()

  325. {

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

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

  328.             jack_default_audio_sample_t* buffer = GetOutputBuffer(i);

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

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

  331.             // Monitor ports

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

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

  334.             }

  335.         } else {

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

  337.         }

  338.     }

  339.     return 0;

  340. }

  341. 

  342. OSStatus JackCoreAudioDriver::SRNotificationCallback(AudioDeviceID inDevice,

  343.                                                     UInt32 inChannel,

  344.                                                     Boolean	isInput,

  345.                                                     AudioDevicePropertyID inPropertyID,

  346.                                                     void* inClientData)

  347. {

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

  349. 

  350.     switch (inPropertyID) {

  351. 

  352.         case kAudioDevicePropertyNominalSampleRate: {

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

  354.             // Check new sample rate

  355.             Float64 tmp_sample_rate;

  356.             UInt32 outSize =  sizeof(Float64);

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

  358.             if (err != noErr) {

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

  360.                 printError(err);

  361.             } else {

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

  363.             }

  364.             driver->fState = true;

  365.             break;

  366.         }

  367.     }

  368. 

  369.     return noErr;

  370. }

  371. 

  372. OSStatus JackCoreAudioDriver::BSNotificationCallback(AudioDeviceID inDevice,

  373.                                                      UInt32 inChannel,

  374.                                                      Boolean	isInput,

  375.                                                      AudioDevicePropertyID inPropertyID,

  376.                                                      void* inClientData)

  377. {

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

  379. 

  380.     switch (inPropertyID) {

  381. 

  382.         case kAudioDevicePropertyBufferFrameSize: {

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

  384.             // Check new buffer size

  385.             UInt32 tmp_buffer_size;

  386.             UInt32 outSize =  sizeof(UInt32);

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

  388.             if (err != noErr) {

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

  390.                 printError(err);

  391.             } else {

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

  393.             }

  394.             driver->fState = true;

  395.             break;

  396.         }

  397.     }

  398. 

  399.     return noErr;

  400. }

  401. 

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

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

  404. {

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

  406. 

  407.     switch (inPropertyID) {

  408. 

  409.             case kAudioHardwarePropertyDevices: {

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

  411.                 DisplayDeviceNames();

  412.                 AudioDeviceID captureID, playbackID;

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

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

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

  416. 

  417.                 }

  418.                 break;

  419.             }

  420. 

  421.     }

  422. 

  423.     return noErr;

  424. }

  425. 

  426. OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,

  427.                                                         UInt32 inChannel,

  428.                                                         Boolean	isInput,

  429.                                                         AudioDevicePropertyID inPropertyID,

  430.                                                         void* inClientData)

  431. {

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

  433. 

  434.     switch (inPropertyID) {

  435. 

  436.         case kAudioDevicePropertyDeviceIsRunning: {

  437.             UInt32 isrunning = 0;

  438.             UInt32 outsize = sizeof(UInt32);

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

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

  441.             }

  442.             break;

  443.         }

  444. 

  445.         case kAudioDevicePropertyDeviceIsAlive: {

  446.             UInt32 isalive = 0;

  447.             UInt32 outsize = sizeof(UInt32);

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

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

  450.             }

  451.             break;

  452.         }

  453. 

  454.         case kAudioDevicePropertyDeviceHasChanged: {

  455.             UInt32 hachanged = 0;

  456.             UInt32 outsize = sizeof(UInt32);

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

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

  459.             }

  460.             break;

  461.         }

  462. 

  463.         case kAudioDeviceProcessorOverload: {

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

  465.             jack_time_t cur_time = GetMicroSeconds();

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

  467.             break;

  468.         }

  469. 

  470.         case kAudioDevicePropertyStreamConfiguration: {

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

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

  473.             driver->CloseAUHAL();

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

  475.             return kAudioHardwareUnsupportedOperationError;

  476.         }

  477. 

  478.         case kAudioDevicePropertyNominalSampleRate: {

  479.             Float64 sample_rate = 0;

  480.             UInt32 outsize = sizeof(Float64);

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

  482.             if (err != noErr) {

  483.                 return kAudioHardwareUnsupportedOperationError;

  484.             }

  485. 

  486.             char device_name[256];

  487.             const char* digidesign_name = "Digidesign";

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

  489. 

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

  491. 

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

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

  494. 

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

  496. 

  497.                     // Set sample rate again...

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

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

  500.                     if (err != noErr) {

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

  502.                         printError(err);

  503.                     } else {

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

  505.                     }

  506. 

  507.                     // Check new sample rate again...

  508.                     outsize = sizeof(Float64);

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

  510.                     if (err != noErr) {

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

  512.                         printError(err);

  513.                     } else {

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

  515.                     }

  516.                     return noErr;

  517. 

  518.                 } else {

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

  520.                     driver->CloseAUHAL();

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

  522.                     return kAudioHardwareUnsupportedOperationError;

  523.                 }

  524.             }

  525.         }

  526. 

  527.     }

  528.     return noErr;

  529. }

  530. 

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

  532. {

  533.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  536. 

  537.     if (inIUD == NULL) {

  538.         return kAudioHardwareUnspecifiedError;

  539.     } else {

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

  541.         CFRelease(inIUD);

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

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

  544.     }

  545. }

  546. 

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

  548. {

  549.     OSStatus res;

  550.     UInt32 theSize = sizeof(UInt32);

  551.     AudioDeviceID inDefault;

  552.     AudioDeviceID outDefault;

  553. 

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

  555.         return res;

  556.     }

  557. 

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

  559.         return res;

  560.     }

  561. 

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

  563. 

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

  565.     if (inDefault != outDefault) {

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

  567.         return kAudioHardwareBadDeviceError;

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

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

  570.         return kAudioHardwareBadDeviceError;

  571.     } else {

  572.         *id = inDefault;

  573.         return noErr;

  574.     }

  575. }

  576. 

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

  578. {

  579.     OSStatus res;

  580.     UInt32 theSize = sizeof(UInt32);

  581.     AudioDeviceID inDefault;

  582. 

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

  584.         return res;

  585.     }

  586. 

  587.     if (inDefault == 0) {

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

  589.         return -1;

  590.     }

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

  592.     *id = inDefault;

  593.     return noErr;

  594. }

  595. 

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

  597. {

  598.     OSStatus res;

  599.     UInt32 theSize = sizeof(UInt32);

  600.     AudioDeviceID outDefault;

  601. 

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

  603.         return res;

  604.     }

  605. 

  606.     if (outDefault == 0) {

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

  608.         return -1;

  609.     }

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

  611.     *id = outDefault;

  612.     return noErr;

  613. }

  614. 

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

  616. {

  617.     UInt32 size = 256;

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

  619. }

  620. 

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

  622. {

  623.     OSStatus err = noErr;

  624.     UInt32 outSize;

  625.     Boolean	outWritable;

  626. 

  627.     channelCount = 0;

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

  629.     if (err == noErr) {

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

  631.         AudioBufferList bufferList[stream_count];

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

  633.         if (err == noErr) {

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

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

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

  637.             }

  638.         }

  639.     }

  640.     return err;

  641. }

  642. 

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

  644. {

  645.     OSStatus err = noErr;

  646.     UInt32 outSize1, outSize2, outSize3;

  647.     Boolean	outWritable;

  648. 

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

  650.     if (err == noErr) {

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

  652.         AudioStreamID streamIDs[stream_count];

  653.         AudioBufferList bufferList[stream_count];

  654.         UInt32 streamLatency;

  655.         outSize2 = sizeof(UInt32);

  656. 

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

  658.         if (err != noErr) {

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

  660.             return err;

  661.         }

  662. 

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

  664.         if (err != noErr) {

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

  666.             return err;

  667.         }

  668. 

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

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

  671.             if (err != noErr) {

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

  673.                 return err;

  674.             }

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

  676.             if (err != noErr) {

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

  678.                 return err;

  679.             }

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

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

  682.                 latencies.push_back(streamLatency);

  683.             }

  684.         }

  685.     }

  686.     return err;

  687. }

  688. 

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

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

  691.         fJackInputData(NULL),

  692.         fDriverOutputData(NULL),

  693.         fPluginID(0),

  694.         fState(false),

  695.         fHogged(false),

  696.         fIOUsage(1.f),

  697.         fComputationGrain(-1.f),

  698.         fClockDriftCompensate(false)

  699. {}

  700. 

  701. JackCoreAudioDriver::~JackCoreAudioDriver()

  702. {}

  703. 

  704. OSStatus JackCoreAudioDriver::DestroyAggregateDevice()

  705. {

  706.     OSStatus osErr = noErr;

  707.     AudioObjectPropertyAddress pluginAOPA;

  708.     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;

  709.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  710.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  711.     UInt32 outDataSize;

  712. 

  713.     if (fPluginID > 0) {

  714. 

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

  716.         if (osErr != noErr) {

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

  718.             printError(osErr);

  719.             return osErr;

  720.         }

  721. 

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

  723.         if (osErr != noErr) {

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

  725.             printError(osErr);

  726.             return osErr;

  727.         }

  728. 

  729.     }

  730. 

  731.     return noErr;

  732. }

  733. 

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

  735. {

  736.     OSStatus err = noErr;

  737.     AudioObjectID sub_device[32];

  738.     UInt32 outSize = sizeof(sub_device);

  739. 

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

  741.     vector<AudioDeviceID> captureDeviceIDArray;

  742. 

  743.     if (err != noErr) {

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

  745.         captureDeviceIDArray.push_back(captureDeviceID);

  746.     } else {

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

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

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

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

  751.         }

  752.     }

  753. 

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

  755.     vector<AudioDeviceID> playbackDeviceIDArray;

  756. 

  757.     if (err != noErr) {

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

  759.         playbackDeviceIDArray.push_back(playbackDeviceID);

  760.     } else {

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

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

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

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

  765.         }

  766.     }

  767. 

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

  769. }

  770. 

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

  772. {

  773.     OSStatus osErr = noErr;

  774.     UInt32 outSize;

  775.     Boolean outWritable;

  776. 

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

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

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

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

  781.     UInt32 theQualifierDataSize = sizeof(AudioObjectID);

  782.     AudioClassID inClass = kAudioSubDeviceClassID;

  783.     void* theQualifierData = &inClass;

  784.     UInt32 subDevicesNum = 0;

  785. 

  786.     //---------------------------------------------------------------------------

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

  788.     //---------------------------------------------------------------------------

  789.     UInt32 keptclockdomain = 0;

  790.     UInt32 clockdomain = 0;

  791.     outSize = sizeof(UInt32);

  792.     bool need_clock_drift_compensation = false;

  793. 

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

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

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

  797.         } else  {

  798.             // Check clock domain

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

  800.             if (osErr != 0) {

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

  802.                 printError(osErr);

  803.             } else {

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

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

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

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

  808.                     need_clock_drift_compensation = true;

  809.                 }

  810.             }

  811.         }

  812.     }

  813. 

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

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

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

  817.         } else {

  818.             // Check clock domain

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

  820.             if (osErr != 0) {

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

  822.                 printError(osErr);

  823.             } else {

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

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

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

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

  828.                     need_clock_drift_compensation = true;

  829.                 }

  830.             }

  831.         }

  832.     }

  833. 

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

  835.     if (keptclockdomain == 0) {

  836.         need_clock_drift_compensation = true;

  837.     }

  838. 

  839.     //---------------------------------------------------------------------------

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

  841.     //---------------------------------------------------------------------------

  842. 

  843.     char device_name[256];

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

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

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

  847.     }

  848. 

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

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

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

  852.     }

  853. 

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

  855.     if (osErr != noErr) {

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

  857.         printError(osErr);

  858.         return osErr;

  859.     }

  860. 

  861.     AudioValueTranslation pluginAVT;

  862. 

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

  864. 

  865.     pluginAVT.mInputData = &inBundleRef;

  866.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  867.     pluginAVT.mOutputData = &fPluginID;

  868.     pluginAVT.mOutputDataSize = sizeof(fPluginID);

  869. 

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

  871.     if (osErr != noErr) {

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

  873.         printError(osErr);

  874.         return osErr;

  875.     }

  876. 

  877.     //-------------------------------------------------

  878.     // Create a CFDictionary for our aggregate device

  879.     //-------------------------------------------------

  880. 

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

  882. 

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

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

  885. 

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

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

  888. 

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

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

  891. 

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

  893.     int value = 1;

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

  895. 

  896.     SInt32 system;

  897.     Gestalt(gestaltSystemVersion, &system);

  898. 

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

  900. 

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

  902.     if (system < 0x00001054) {

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

  904.     } else {

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

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

  907.     }

  908. 

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

  910.     CFMutableArrayRef subDevicesArrayClock = NULL;

  911. 

  912.     /*

  913.     if (fClockDriftCompensate) {

  914.         if (need_clock_drift_compensation) {

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

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

  917. 

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

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

  920.                 if (UID) {

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

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

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

  924.                     //CFRelease(UID);

  925.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  926.                 }

  927.             }

  928. 

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

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

  931.                 if (UID) {

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

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

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

  935.                     //CFRelease(UID);

  936.                     CFArrayAppendValue(subDevicesArrayClock, subdeviceAggDeviceDict);

  937.                 }

  938.             }

  939. 

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

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

  942.         } else {

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

  944.         }

  945.     }

  946.     */

  947. 

  948.     //-------------------------------------------------

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

  950.     //-------------------------------------------------

  951. 

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

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

  954. 

  955.     vector<CFStringRef> captureDeviceUID;

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

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

  958.         if (ref == NULL) {

  959.             return -1;

  960.         }

  961.         captureDeviceUID.push_back(ref);

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

  963.         CFArrayAppendValue(subDevicesArray, ref);

  964.    }

  965. 

  966.     vector<CFStringRef> playbackDeviceUID;

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

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

  969.         if (ref == NULL) {

  970.             return -1;

  971.         }

  972.         playbackDeviceUID.push_back(ref);

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

  974.         CFArrayAppendValue(subDevicesArray, ref);

  975.     }

  976. 

  977.     //-----------------------------------------------------------------------

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

  979.     //-----------------------------------------------------------------------

  980. 

  981.     AudioObjectPropertyAddress pluginAOPA;

  982.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  983.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  984.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  985.     UInt32 outDataSize;

  986. 

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

  988.     if (osErr != noErr) {

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

  990.         printError(osErr);

  991.         goto error;

  992.     }

  993. 

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

  995.     if (osErr != noErr) {

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

  997.         printError(osErr);

  998.         goto error;

  999.     }

  1000. 

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

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

  1003.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1004. 

  1005.     //-------------------------

  1006.     // Set the sub-device list

  1007.     //-------------------------

  1008. 

  1009.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  1010.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1011.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1012.     outDataSize = sizeof(CFMutableArrayRef);

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

  1014.     if (osErr != noErr) {

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

  1016.         printError(osErr);

  1017.         goto error;

  1018.     }

  1019. 

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

  1021.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1022. 

  1023.     //-----------------------

  1024.     // Set the master device

  1025.     //-----------------------

  1026. 

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

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

  1029.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  1030.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1031.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1032.     outDataSize = sizeof(CFStringRef);

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

  1034.     if (osErr != noErr) {

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

  1036.         printError(osErr);

  1037.         goto error;

  1038.     }

  1039. 

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

  1041.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1042. 

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

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

  1045. 

  1046.     if (fClockDriftCompensate) {

  1047.         if (need_clock_drift_compensation) {

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

  1049. 

  1050.             // Get the property data size

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

  1052.             if (osErr != noErr) {

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

  1054.                 printError(osErr);

  1055.             }

  1056. 

  1057.             //	Calculate the number of object IDs

  1058.             subDevicesNum = outSize / sizeof(AudioObjectID);

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

  1060.             AudioObjectID subDevices[subDevicesNum];

  1061.             outSize = sizeof(subDevices);

  1062. 

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

  1064.             if (osErr != noErr) {

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

  1066.                 printError(osErr);

  1067.             }

  1068. 

  1069.             // Set kAudioSubDevicePropertyDriftCompensation property...

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

  1071.                 UInt32 theDriftCompensationValue = 1;

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

  1073.                 if (osErr != noErr) {

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

  1075.                     printError(osErr);

  1076.                 }

  1077.             }

  1078.         } else {

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

  1080.         }

  1081.     }

  1082. 

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

  1084.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1085. 

  1086.     //----------

  1087.     // Clean up

  1088.     //----------

  1089. 

  1090.     // release the private AD key

  1091.     CFRelease(AggregateDeviceNumberRef);

  1092. 

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

  1094.     CFRelease(aggDeviceDict);

  1095.     CFRelease(subDevicesArray);

  1096. 

  1097.     if (subDevicesArrayClock) {

  1098.         CFRelease(subDevicesArrayClock);

  1099.     }

  1100. 

  1101.     // release the device UID

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

  1103.         CFRelease(captureDeviceUID[i]);

  1104.     }

  1105. 

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

  1107.         CFRelease(playbackDeviceUID[i]);

  1108.     }

  1109. 

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

  1111.     return noErr;

  1112. 

  1113. error:

  1114.     DestroyAggregateDevice();

  1115.     return -1;

  1116. }

  1117. 

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

  1119.                                       const char* playback_driver_uid,

  1120.                                       char* capture_driver_name,

  1121.                                       char* playback_driver_name,

  1122.                                       jack_nframes_t samplerate)

  1123. {

  1124.     capture_driver_name[0] = 0;

  1125.     playback_driver_name[0] = 0;

  1126. 

  1127.     // Duplex

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

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

  1130. 

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

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

  1133. 

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

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

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

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

  1138.                     return -1;

  1139.                 }

  1140.             }

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

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

  1143.                 return -1;

  1144.             }

  1145. 

  1146.         } else {

  1147. 

  1148.             // Creates aggregate device

  1149.             AudioDeviceID captureID, playbackID;

  1150. 

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

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

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

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

  1155.                     return -1;

  1156.                 }

  1157.             }

  1158. 

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

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

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

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

  1163.                     return -1;

  1164.                 }

  1165.             }

  1166. 

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

  1168.                 return -1;

  1169.             }

  1170. 

  1171.             GetDeviceNameFromID(captureID, fCaptureUID);

  1172.             GetDeviceNameFromID(playbackID, fPlaybackUID);

  1173.          }

  1174. 

  1175.     // Capture only

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

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

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

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

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

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

  1182.                 return -1;

  1183.             }

  1184.         }

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

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

  1187.             return -1;

  1188.         }

  1189. 

  1190.     // Playback only

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

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

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

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

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

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

  1197.                 return -1;

  1198.             }

  1199.         }

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

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

  1202.             return -1;

  1203.         }

  1204. 

  1205.     // Use default driver in duplex mode

  1206.     } else {

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

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

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

  1210. 

  1211.             // Creates aggregate device

  1212.             AudioDeviceID captureID, playbackID;

  1213. 

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

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

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

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

  1218.                     return -1;

  1219.                 }

  1220.             }

  1221. 

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

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

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

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

  1226.                     return -1;

  1227.                 }

  1228.             }

  1229. 

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

  1231.                 return -1;

  1232.             }

  1233. 

  1234.             GetDeviceNameFromID(captureID, fCaptureUID);

  1235.             GetDeviceNameFromID(playbackID, fPlaybackUID);

  1236.         }

  1237.     }

  1238. 

  1239.     if (fHogged) {

  1240.         if (TakeHog()) {

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

  1242.         }

  1243.     }

  1244. 

  1245.     return 0;

  1246. }

  1247. 

  1248. /*

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

  1250. */

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

  1252. {

  1253.     OSStatus err = noErr;

  1254. 

  1255.     if (capturing) {

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

  1257.         if (err != noErr) {

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

  1259.             printError(err);

  1260.             return -1;

  1261.         } else {

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

  1263.         }

  1264.     }

  1265. 

  1266.     if (playing) {

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

  1268.         if (err != noErr) {

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

  1270.             printError(err);

  1271.             return -1;

  1272.         } else {

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

  1274.         }

  1275.     }

  1276. 

  1277.     if (inchannels > in_nChannels) {

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

  1279.         if (strict) {

  1280.             return -1;

  1281.         }

  1282.     }

  1283. 

  1284.     if (outchannels > out_nChannels) {

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

  1286.         if (strict) {

  1287.             return -1;

  1288.         }

  1289.     }

  1290. 

  1291.     if (inchannels == -1) {

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

  1293.         inchannels = in_nChannels;

  1294.     }

  1295. 

  1296.     if (outchannels == -1) {

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

  1298.         outchannels = out_nChannels;

  1299.     }

  1300. 

  1301.     return 0;

  1302. }

  1303. 

  1304. int JackCoreAudioDriver::SetupBufferSize(jack_nframes_t buffer_size)

  1305. {

  1306.     // Setting buffer size

  1307.     OSStatus err = noErr;

  1308.     UInt32 tmp_buffer_size = buffer_size;

  1309.     UInt32 outSize = sizeof(UInt32);

  1310. 

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

  1312.     if (err != noErr) {

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

  1314.         printError(err);

  1315.         return -1;

  1316.     } else {

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

  1318.     }

  1319. 

  1320.     // If needed, set new buffer size

  1321.     if (buffer_size != tmp_buffer_size) {

  1322.         tmp_buffer_size = buffer_size;

  1323. 

  1324.         // To get BS change notification

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

  1326.         if (err != noErr) {

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

  1328.             printError(err);

  1329.             return -1;

  1330.         }

  1331. 

  1332.         // Waiting for BS change notification

  1333.         int count = 0;

  1334.         fState = false;

  1335. 

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

  1337.         if (err != noErr) {

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

  1339.             printError(err);

  1340.             goto error;

  1341.         }

  1342. 

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

  1344.             usleep(100000);

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

  1346.         }

  1347. 

  1348.         if (count >= WAIT_NOTIFICATION_COUNTER) {

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

  1350.             goto error;

  1351.         }

  1352. 

  1353.         // Check new buffer size

  1354.         outSize =  sizeof(UInt32);

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

  1356.         if (err != noErr) {

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

  1358.             printError(err);

  1359.         } else {

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

  1361.         }

  1362. 

  1363.         // Remove BS change notification

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

  1365.     }

  1366. 

  1367.     return 0;

  1368. 

  1369. error:

  1370. 

  1371.     // Remove SR change notification

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

  1373.     return -1;

  1374. 

  1375. }

  1376. 

  1377. int JackCoreAudioDriver::SetupSampleRate(jack_nframes_t sample_rate)

  1378. {

  1379.     return SetupSampleRateAux(fDeviceID, sample_rate);

  1380. }

  1381. 

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

  1383. {

  1384.     OSStatus err = noErr;

  1385.     UInt32 outSize;

  1386.     Float64 tmp_sample_rate;

  1387. 

  1388.     // Get sample rate

  1389.     outSize =  sizeof(Float64);

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

  1391.     if (err != noErr) {

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

  1393.         printError(err);

  1394.         return -1;

  1395.     } else {

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

  1397.     }

  1398. 

  1399.     // If needed, set new sample rate

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

  1401.         tmp_sample_rate = (Float64)sample_rate;

  1402. 

  1403.         // To get SR change notification

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

  1405.         if (err != noErr) {

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

  1407.             printError(err);

  1408.             return -1;

  1409.         }

  1410. 

  1411.         // Waiting for SR change notification

  1412.         int count = 0;

  1413.         fState = false;

  1414. 

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

  1416.         if (err != noErr) {

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

  1418.             printError(err);

  1419.             goto error;

  1420.         }

  1421. 

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

  1423.             usleep(100000);

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

  1425.         }

  1426. 

  1427.         if (count >= WAIT_NOTIFICATION_COUNTER) {

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

  1429.             goto error;

  1430.         }

  1431. 

  1432.         // Check new sample rate

  1433.         outSize =  sizeof(Float64);

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

  1435.         if (err != noErr) {

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

  1437.             printError(err);

  1438.         } else {

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

  1440.         }

  1441. 

  1442.         // Remove SR change notification

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

  1444.     }

  1445. 

  1446.     return 0;

  1447. 

  1448. error:

  1449. 

  1450.     // Remove SR change notification

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

  1452.     return -1;

  1453. }

  1454. 

  1455. int JackCoreAudioDriver::OpenAUHAL(bool capturing,

  1456.                                    bool playing,

  1457.                                    int inchannels,

  1458.                                    int outchannels,

  1459.                                    int in_nChannels,

  1460.                                    int out_nChannels,

  1461.                                    const vector<int>& chan_in_list,

  1462.                                    const vector<int>& chan_out_list,

  1463.                                    jack_nframes_t buffer_size,

  1464.                                    jack_nframes_t sample_rate)

  1465. {

  1466.     ComponentResult err1;

  1467.     UInt32 enableIO;

  1468.     AudioStreamBasicDescription srcFormat, dstFormat;

  1469.     AudioDeviceID currAudioDeviceID;

  1470.     UInt32 size;

  1471. 

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

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

  1474. 

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

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

  1477.         return -1;

  1478.     }

  1479. 

  1480.     // AUHAL

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

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

  1483. 

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

  1485.     if (err1 != noErr) {

  1486.         jack_error("Error calling OpenAComponent");

  1487.         printError(err1);

  1488.         goto error;

  1489.     }

  1490. 

  1491.     err1 = AudioUnitInitialize(fAUHAL);

  1492.     if (err1 != noErr) {

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

  1494.         printError(err1);

  1495.         goto error;

  1496.     }

  1497. 

  1498.     // Start I/O

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

  1500.         enableIO = 1;

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

  1502.     } else {

  1503.         enableIO = 0;

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

  1505.     }

  1506. 

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

  1508.     if (err1 != noErr) {

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

  1510.         printError(err1);

  1511.         goto error;

  1512.     }

  1513. 

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

  1515.         enableIO = 1;

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

  1517.     } else {

  1518.         enableIO = 0;

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

  1520.     }

  1521. 

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

  1523.     if (err1 != noErr) {

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

  1525.         printError(err1);

  1526.         goto error;

  1527.     }

  1528. 

  1529.     size = sizeof(AudioDeviceID);

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

  1531.     if (err1 != noErr) {

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

  1533.         printError(err1);

  1534.         goto error;

  1535.     } else {

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

  1537.     }

  1538. 

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

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

  1541.     if (err1 != noErr) {

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

  1543.         printError(err1);

  1544.         goto error;

  1545.     }

  1546. 

  1547.     // Set buffer size

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

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

  1550.         if (err1 != noErr) {

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

  1552.             printError(err1);

  1553.             goto error;

  1554.         }

  1555.     }

  1556. 

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

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

  1559.         if (err1 != noErr) {

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

  1561.             printError(err1);

  1562.             goto error;

  1563.         }

  1564.     }

  1565. 

  1566.     // Setup input channel map

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

  1568.         SInt32 chanArr[in_nChannels];

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

  1570.             chanArr[i] = -1;

  1571.         }

  1572.         // Explicit mapping

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

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

  1575.                 int chan = chan_in_list[i];

  1576.                 if (chan < out_nChannels) {

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

  1578.                     chanArr[chan] = i;

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

  1580.                 } else {

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

  1582.                     goto error;

  1583.                 }

  1584.             }

  1585.         } else {

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

  1587.                 chanArr[i] = i;

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

  1589.             }

  1590.         }

  1591. 

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

  1593.         if (err1 != noErr) {

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

  1595.             printError(err1);

  1596.             goto error;

  1597.         }

  1598.     }

  1599. 

  1600.     // Setup output channel map

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

  1602.         SInt32 chanArr[out_nChannels];

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

  1604.             chanArr[i] = -1;

  1605.         }

  1606.         // Explicit mapping

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

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

  1609.                 int chan = chan_out_list[i];

  1610.                 if (chan < out_nChannels) {

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

  1612.                     chanArr[chan] = i;

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

  1614.                 } else {

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

  1616.                     goto error;

  1617.                 }

  1618.             }

  1619.         } else {

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

  1621.                 chanArr[i] = i;

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

  1623.             }

  1624.         }

  1625. 

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

  1627.         if (err1 != noErr) {

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

  1629.             printError(err1);

  1630.             goto error;

  1631.         }

  1632.     }

  1633. 

  1634.     // Setup stream converters

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

  1636. 

  1637.         size = sizeof(AudioStreamBasicDescription);

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

  1639.         if (err1 != noErr) {

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

  1641.             printError(err1);

  1642.             goto error;

  1643.         }

  1644.         PrintStreamDesc(&srcFormat);

  1645. 

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

  1647.         srcFormat.mSampleRate = sample_rate;

  1648.         srcFormat.mFormatID = kAudioFormatLinearPCM;

  1649.         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1650.         srcFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1651.         srcFormat.mFramesPerPacket = 1;

  1652.         srcFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1653.         srcFormat.mChannelsPerFrame = inchannels;

  1654.         srcFormat.mBitsPerChannel = 32;

  1655.         PrintStreamDesc(&srcFormat);

  1656. 

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

  1658.         if (err1 != noErr) {

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

  1660.             printError(err1);

  1661.             goto error;

  1662.         }

  1663.     }

  1664. 

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

  1666. 

  1667.         size = sizeof(AudioStreamBasicDescription);

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

  1669.         if (err1 != noErr) {

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

  1671.             printError(err1);

  1672.             goto error;

  1673.         }

  1674.         PrintStreamDesc(&dstFormat);

  1675. 

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

  1677.         dstFormat.mSampleRate = sample_rate;

  1678.         dstFormat.mFormatID = kAudioFormatLinearPCM;

  1679.         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  1680.         dstFormat.mBytesPerPacket = sizeof(jack_default_audio_sample_t);

  1681.         dstFormat.mFramesPerPacket = 1;

  1682.         dstFormat.mBytesPerFrame = sizeof(jack_default_audio_sample_t);

  1683.         dstFormat.mChannelsPerFrame = outchannels;

  1684.         dstFormat.mBitsPerChannel = 32;

  1685.         PrintStreamDesc(&dstFormat);

  1686. 

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

  1688.         if (err1 != noErr) {

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

  1690.             printError(err1);

  1691.             goto error;

  1692.         }

  1693.     }

  1694. 

  1695.     // Setup callbacks

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

  1697.         AURenderCallbackStruct output;

  1698.         output.inputProc = Render;

  1699.         output.inputProcRefCon = this;

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

  1701.         if (err1 != noErr) {

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

  1703.             printError(err1);

  1704.             goto error;

  1705.         }

  1706.     } else {

  1707.         AURenderCallbackStruct output;

  1708.         output.inputProc = Render;

  1709.         output.inputProcRefCon = this;

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

  1711.         if (err1 != noErr) {

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

  1713.             printError(err1);

  1714.             goto error;

  1715.         }

  1716.     }

  1717. 

  1718.     return 0;

  1719. 

  1720. error:

  1721.     CloseAUHAL();

  1722.     return -1;

  1723. }

  1724. 

  1725. int JackCoreAudioDriver::SetupBuffers(int inchannels)

  1726. {

  1727.     // Prepare buffers

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

  1729.     fJackInputData->mNumberBuffers = inchannels;

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

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

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

  1733.     }

  1734.     return 0;

  1735. }

  1736. 

  1737. void JackCoreAudioDriver::DisposeBuffers()

  1738. {

  1739.     if (fJackInputData) {

  1740.         free(fJackInputData);

  1741.         fJackInputData = 0;

  1742.     }

  1743. }

  1744. 

  1745. void JackCoreAudioDriver::CloseAUHAL()

  1746. {

  1747.     AudioOutputUnitStop(fAUHAL);

  1748.     AudioUnitUninitialize(fAUHAL);

  1749.     CloseComponent(fAUHAL);

  1750. }

  1751. 

  1752. int JackCoreAudioDriver::AddListeners()

  1753. {

  1754.     OSStatus err = noErr;

  1755. 

  1756.     // Add listeners

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

  1758.     if (err != noErr) {

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

  1760.         printError(err);

  1761.         return -1;

  1762.     }

  1763. 

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

  1765.     if (err != noErr) {

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

  1767.         printError(err);

  1768.         return -1;

  1769.     }

  1770. 

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

  1772.     if (err != noErr) {

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

  1774.         printError(err);

  1775.         return -1;

  1776.     }

  1777. 

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

  1779.     if (err != noErr) {

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

  1781.         printError(err);

  1782.         return -1;

  1783.     }

  1784. 

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

  1786.     if (err != noErr) {

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

  1788.         printError(err);

  1789.         return -1;

  1790.     }

  1791. 

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

  1793.     if (err != noErr) {

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

  1795.         printError(err);

  1796.         return -1;

  1797.     }

  1798. 

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

  1800.     if (err != noErr) {

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

  1802.         printError(err);

  1803.         return -1;

  1804.     }

  1805. 

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

  1807.     if (err != noErr) {

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

  1809.         printError(err);

  1810.         return -1;

  1811.     }

  1812. 

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

  1814.         UInt32 outSize = sizeof(float);

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

  1816.         if (err != noErr) {

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

  1818.             printError(err);

  1819.         }

  1820.     }

  1821. 

  1822.     return 0;

  1823. }

  1824. 

  1825. void JackCoreAudioDriver::RemoveListeners()

  1826. {

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

  1828.     AudioHardwareRemovePropertyListener(kAudioHardwarePropertyDevices, AudioHardwareNotificationCallback);

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

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

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

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

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

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

  1835. }

  1836. 

  1837. int JackCoreAudioDriver::Open(jack_nframes_t buffer_size,

  1838.                               jack_nframes_t sample_rate,

  1839.                               bool capturing,

  1840.                               bool playing,

  1841.                               int inchannels,

  1842.                               int outchannels,

  1843.                               const char* chan_in_list,

  1844.                               const char* chan_out_list,

  1845.                               bool monitor,

  1846.                               const char* capture_driver_uid,

  1847.                               const char* playback_driver_uid,

  1848.                               jack_nframes_t capture_latency,

  1849.                               jack_nframes_t playback_latency,

  1850.                               int async_output_latency,

  1851.                               int computation_grain,

  1852.                               bool hogged,

  1853.                               bool clock_drift)

  1854. {

  1855.     int in_nChannels = 0;

  1856.     int out_nChannels = 0;

  1857.     char capture_driver_name[256];

  1858.     char playback_driver_name[256];

  1859. 

  1860.     fCaptureLatency = capture_latency;

  1861.     fPlaybackLatency = playback_latency;

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

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

  1864.     fHogged = hogged;

  1865.     fClockDriftCompensate = clock_drift;

  1866. 

  1867.     SInt32 major;

  1868.     SInt32 minor;

  1869.     Gestalt(gestaltSystemVersionMajor, &major);

  1870.     Gestalt(gestaltSystemVersionMinor, &minor);

  1871. 

  1872.     vector<int> parsed_chan_in_list;

  1873.     vector<int> parsed_chan_out_list;

  1874. 

  1875.     ParseChannelList(chan_in_list, parsed_chan_in_list);

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

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

  1878.         inchannels = parsed_chan_in_list.size();

  1879.     }

  1880. 

  1881.     ParseChannelList(chan_out_list, parsed_chan_out_list);

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

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

  1884.         outchannels = parsed_chan_out_list.size();

  1885.     }

  1886. 

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

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

  1889.         CFRunLoopRef theRunLoop = NULL;

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

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

  1892.         if (osErr != noErr) {

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

  1894.             printError(osErr);

  1895.         }

  1896.     }

  1897. 

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

  1899.         goto error;

  1900.     }

  1901. 

  1902.     // Generic JackAudioDriver Open

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

  1904.                             capturing, playing,

  1905.                             inchannels, outchannels,

  1906.                             monitor,

  1907.                             capture_driver_name,

  1908.                             playback_driver_name,

  1909.                             capture_latency,

  1910.                             playback_latency) != 0) {

  1911.         goto error;

  1912.     }

  1913. 

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

  1915.         goto error;

  1916.     }

  1917. 

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

  1919.         goto error;

  1920.     }

  1921. 

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

  1923.         goto error;

  1924.     }

  1925. 

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

  1927.         goto error;

  1928.     }

  1929. 

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

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

  1932.             goto error;

  1933.         }

  1934.     }

  1935. 

  1936.     if (AddListeners() < 0) {

  1937.         goto error;

  1938.     }

  1939. 

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

  1941.     fCaptureChannels = inchannels;

  1942.     fPlaybackChannels = outchannels;

  1943.     return noErr;

  1944. 

  1945. error:

  1946.     Close();

  1947.     return -1;

  1948. }

  1949. 

  1950. int JackCoreAudioDriver::Close()

  1951. {

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

  1953. 

  1954.     // Generic audio driver close

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

  1956. 

  1957.     RemoveListeners();

  1958.     DisposeBuffers();

  1959.     CloseAUHAL();

  1960.     DestroyAggregateDevice();

  1961.     return res;

  1962. }

  1963. 

  1964. void JackCoreAudioDriver::UpdateLatencies()

  1965. {

  1966.     UInt32 size;

  1967.     OSStatus err;

  1968.     jack_latency_range_t input_range;

  1969.     jack_latency_range_t output_range;

  1970.     jack_latency_range_t monitor_range;

  1971. 

  1972.     // Get Input latency

  1973.     size = sizeof(UInt32);

  1974.     UInt32 value1 = 0;

  1975.     UInt32 value2 = 0;

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

  1977.     if (err != noErr) {

  1978.         jack_error("AudioDeviceGetProperty kAudioDevicePropertyLatency error");

  1979.     }

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

  1981.     if (err != noErr) {

  1982.         jack_error("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");

  1983.     }

  1984. 

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

  1986. 

  1987.     // Get input stream latencies

  1988.     vector<int> input_latencies;

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

  1990. 

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

  1992.         if (err != noErr) {

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

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

  1995.         }

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

  1997.     }

  1998. 

  1999.     // Get Output latency

  2000.     size = sizeof(UInt32);

  2001.     value1 = 0;

  2002.     value2 = 0;

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

  2004.     if (err != noErr) {

  2005.         jack_error("AudioDeviceGetProperty kAudioDevicePropertyLatency error");

  2006.     }

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

  2008.     if (err != noErr) {

  2009.         jack_error("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error");

  2010.     }

  2011. 

  2012.     // Get output stream latencies

  2013.     vector<int> output_latencies;

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

  2015. 

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

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

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

  2019. 

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

  2021.         if (err != noErr) {

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

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

  2024.         }

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

  2026. 

  2027.         // Monitor port

  2028.         if (fWithMonitorPorts) {

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

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

  2031.         }

  2032.     }

  2033. }

  2034. 

  2035. int JackCoreAudioDriver::Attach()

  2036. {

  2037.     OSStatus err;

  2038.     JackPort* port;

  2039.     jack_port_id_t port_index;

  2040.     UInt32 size;

  2041.     Boolean isWritable;

  2042.     char channel_name[64];

  2043.     char name[REAL_JACK_PORT_NAME_SIZE];

  2044.     char alias[REAL_JACK_PORT_NAME_SIZE];

  2045. 

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

  2047. 

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

  2049. 

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

  2051.         if (err != noErr) {

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

  2053.         }

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

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

  2056.             if (err != noErr) {

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

  2058.             }

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

  2060.         } else {

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

  2062.         }

  2063. 

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

  2065. 

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

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

  2068.             return -1;

  2069.         }

  2070. 

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

  2072.         port->SetAlias(alias);

  2073.         fCapturePortList[i] = port_index;

  2074.     }

  2075. 

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

  2077. 

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

  2079.         if (err != noErr) {

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

  2081.         }

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

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

  2084.             if (err != noErr) {

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

  2086.             }

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

  2088.         } else {

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

  2090.         }

  2091. 

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

  2093. 

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

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

  2096.             return -1;

  2097.         }

  2098. 

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

  2100.         port->SetAlias(alias);

  2101.         fPlaybackPortList[i] = port_index;

  2102. 

  2103.         // Monitor ports

  2104.         if (fWithMonitorPorts) {

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

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

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

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

  2109.                 return -1;

  2110.             } else {

  2111.                 fMonitorPortList[i] = port_index;

  2112.             }

  2113.         }

  2114.     }

  2115. 

  2116.     UpdateLatencies();

  2117. 

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

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

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

  2121.     }

  2122. 

  2123.     return 0;

  2124. }

  2125. 

  2126. int JackCoreAudioDriver::Start()

  2127. {

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

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

  2130. 

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

  2132.         fState = false;

  2133.         int count = 0;

  2134. 

  2135.         OSStatus err = AudioOutputUnitStart(fAUHAL);

  2136.         if (err == noErr) {

  2137. 

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

  2139.                 usleep(100000);

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

  2141.             }

  2142. 

  2143.             if (count < WAIT_COUNTER) {

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

  2145.                 return 0;

  2146.             }

  2147. 

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

  2149.         }

  2150.         JackAudioDriver::Stop();

  2151.     }

  2152.     return -1;

  2153. }

  2154. 

  2155. int JackCoreAudioDriver::Stop()

  2156. {

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

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

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

  2160.         res = -1;

  2161.     }

  2162.     return res;

  2163. }

  2164. 

  2165. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  2166. {

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

  2168.         return -1;

  2169.     }

  2170. 

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

  2172. 

  2173.     // CoreAudio specific

  2174.     UpdateLatencies();

  2175. 

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

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

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

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

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

  2181.     }

  2182. 

  2183.     return 0;

  2184. }

  2185. 

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

  2187. {

  2188.     pid_t hog_pid;

  2189.     OSStatus err;

  2190. 

  2191.     UInt32 propSize = sizeof(hog_pid);

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

  2193.     if (err) {

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

  2195.         printError(err);

  2196.     }

  2197. 

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

  2199.         hog_pid = getpid();

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

  2201.         if (err != noErr) {

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

  2203.             return false;

  2204.         }

  2205.     }

  2206. 

  2207.     return true;

  2208. }

  2209. 

  2210. bool JackCoreAudioDriver::TakeHog()

  2211. {

  2212.     OSStatus err = noErr;

  2213.     AudioObjectID sub_device[32];

  2214.     UInt32 outSize = sizeof(sub_device);

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

  2216. 

  2217.     if (err != noErr) {

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

  2219.         return TakeHogAux(fDeviceID, true);

  2220.     } else {

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

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

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

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

  2225.                 return false;

  2226.             }

  2227.         }

  2228.         return true;

  2229.     }

  2230. }

  2231. 

  2232. bool JackCoreAudioDriver::IsAggregateDevice(AudioDeviceID device)

  2233. {

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

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

  2236. 

  2237.     if (err != noErr) {

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

  2239.         return false;

  2240.     } else {

  2241.         return (deviceType == kAudioDeviceTransportTypeAggregate);

  2242.     }

  2243. }

  2244. 

  2245. 

  2246. } // end of namespace

  2247. 

  2248. 

  2249. #ifdef __cplusplus

  2250. extern "C"

  2251. {

  2252. #endif

  2253. 

  2254.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor()

  2255.     {

  2256.         jack_driver_desc_t * desc;

  2257.         jack_driver_desc_filler_t filler;

  2258.         jack_driver_param_value_t value;

  2259. 

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

  2261. 

  2262.         value.i = -1;

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

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

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

  2266. 

  2267.         value.str[0] = 0;

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

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

  2270. 

  2271.         value.str[0] = 0;

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

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

  2274. 

  2275.         value.i  = 0;

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

  2277. 

  2278.         value.i  = TRUE;

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

  2280. 

  2281.         value.ui  = 44100U;

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

  2283. 

  2284.         value.ui  = 256U;

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

  2286. 

  2287.         value.str[0] = 0;

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

  2289. 

  2290.         value.ui  = 0;

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

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

  2293. 

  2294.         value.i  = FALSE;

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

  2296. 

  2297.         value.i  = FALSE;

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

  2299. 

  2300.         value.ui  = 100;

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

  2302. 

  2303.         value.ui  = 100;

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

  2305. 

  2306.         value.i = FALSE;

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

  2308. 

  2309.         return desc;

  2310.     }

  2311. 

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

  2313.     {

  2314.         jack_nframes_t srate = 44100;

  2315.         jack_nframes_t frames_per_interrupt = 256;

  2316.         bool capture = false;

  2317.         bool playback = false;

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

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

  2320.         const char* chan_in_list = "";

  2321.         const char* chan_out_list = "";

  2322.         bool monitor = false;

  2323.         const char* capture_driver_uid = "";

  2324.         const char* playback_driver_uid = "";

  2325.         const JSList *node;

  2326.         const jack_driver_param_t *param;

  2327.         jack_nframes_t systemic_input_latency = 0;

  2328.         jack_nframes_t systemic_output_latency = 0;

  2329.         int async_output_latency = 100;

  2330.         int computation_grain = -1;

  2331.         bool hogged = false;

  2332.         bool clock_drift = false;

  2333. 

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

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

  2336. 

  2337.             switch (param->character) {

  2338. 

  2339.                 case 'd':

  2340.                     capture_driver_uid = param->value.str;

  2341.                     playback_driver_uid = param->value.str;

  2342.                     break;

  2343. 

  2344.                 case 'D':

  2345.                     capture = true;

  2346.                     playback = true;

  2347.                     break;

  2348. 

  2349.                 case 'c':

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

  2351.                     break;

  2352. 

  2353.                 case 'i':

  2354.                     chan_in = param->value.i;

  2355.                     break;

  2356. 

  2357.                 case 'o':

  2358.                     chan_out = param->value.i;

  2359.                     break;

  2360. 

  2361.                 case 'n':

  2362.                     chan_in_list = param->value.str;

  2363.                     break;

  2364. 

  2365.                 case 'N':

  2366.                     chan_out_list = param->value.str;

  2367.                     break;

  2368. 

  2369.                 case 'C':

  2370.                     capture = true;

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

  2372.                         capture_driver_uid = param->value.str;

  2373.                     }

  2374.                     break;

  2375. 

  2376.                 case 'P':

  2377.                     playback = true;

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

  2379.                         playback_driver_uid = param->value.str;

  2380.                     }

  2381.                     break;

  2382. 

  2383.                 case 'm':

  2384.                     monitor = param->value.i;

  2385.                     break;

  2386. 

  2387.                 case 'r':

  2388.                     srate = param->value.ui;

  2389.                     break;

  2390. 

  2391.                 case 'p':

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

  2393.                     break;

  2394. 

  2395.                 case 'I':

  2396.                     systemic_input_latency = param->value.ui;

  2397.                     break;

  2398. 

  2399.                 case 'O':

  2400.                     systemic_output_latency = param->value.ui;

  2401.                     break;

  2402. 

  2403.                 case 'l':

  2404.                     Jack::DisplayDeviceNames();

  2405.                     // Stops the server in this case

  2406.                     return NULL;

  2407. 

  2408.                 case 'H':

  2409.                     hogged = true;

  2410.                     break;

  2411. 

  2412.                 case 'L':

  2413.                     async_output_latency = param->value.ui;

  2414.                     break;

  2415. 

  2416.                 case 'G':

  2417.                     computation_grain = param->value.ui;

  2418.                     break;

  2419. 

  2420.                 case 's':

  2421.                     clock_drift = true;

  2422.                     break;

  2423.             }

  2424.         }

  2425. 

  2426.         /* duplex is the default */

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

  2428.             capture = true;

  2429.             playback = true;

  2430.         }

  2431. 

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

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

  2434.         }

  2435. 

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

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

  2438.         }

  2439. 

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

  2441.         if (driver->Open(frames_per_interrupt,

  2442.                         srate, capture,

  2443.                         playback, chan_in,

  2444.                         chan_out, chan_in_list,

  2445.                         chan_out_list, monitor,

  2446.                         capture_driver_uid,

  2447.                         playback_driver_uid,

  2448.                         systemic_input_latency,

  2449.                         systemic_output_latency,

  2450.                         async_output_latency,

  2451.                         computation_grain,

  2452.                         hogged, clock_drift) == 0) {

  2453.             return driver;

  2454.         } else {

  2455.             delete driver;

  2456.             return NULL;

  2457.         }

  2458.     }

  2459. 

  2460. #ifdef __cplusplus

  2461. }

  2462. #endif

  2463.