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

1254 lines
46KB
Raw Blame History 

  1. /*

  2. Copyright (C) 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 "JackCoreAudioAdapter.h"

  21. #include "JackError.h"

  22. #include <unistd.h>

  23. 

  24. #include <CoreServices/CoreServices.h>

  25. 

  26. namespace Jack

  27. {

  28. 

  29. static OSStatus DisplayDeviceNames()

  30. {

  31.     UInt32 size;

  32.     Boolean isWritable;

  33.     int i, deviceNum;

  34.     OSStatus err;

  35.     CFStringRef UIname;

  36. 

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

  38.     if (err != noErr)

  39.         return err;

  40. 

  41.     deviceNum = size / sizeof(AudioDeviceID);

  42.     AudioDeviceID devices[deviceNum];

  43. 

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

  45.     if (err != noErr)

  46.         return err;

  47. 

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

  49.         char device_name[256];

  50.         char internal_name[256];

  51. 

  52.         size = sizeof(CFStringRef);

  53.         UIname = NULL;

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

  55.         if (err == noErr) {

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

  57.         } else {

  58.             goto error;

  59.         }

  60. 

  61.         size = 256;

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

  63.         if (err != noErr)

  64.             return err;

  65. 

  66.         jack_info("Device name = \'%s\', internal_name = \'%s\' (to be used as -C, -P, or -d parameter)", device_name, internal_name);

  67.     }

  68. 

  69.     return noErr;

  70. 

  71. error:

  72.     if (UIname != NULL)

  73.         CFRelease(UIname);

  74.     return err;

  75. }

  76. 

  77. static void printError(OSStatus err)

  78. {

  79.     switch (err) {

  80.         case kAudioHardwareNoError:

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

  82.             break;

  83.         case kAudioConverterErr_FormatNotSupported:

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

  85.             break;

  86.         case kAudioConverterErr_OperationNotSupported:

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

  88.             break;

  89.         case kAudioConverterErr_PropertyNotSupported:

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

  91.             break;

  92.         case kAudioConverterErr_InvalidInputSize:

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

  94.             break;

  95.         case kAudioConverterErr_InvalidOutputSize:

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

  97.             break;

  98.         case kAudioConverterErr_UnspecifiedError:

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

  100.             break;

  101.         case kAudioConverterErr_BadPropertySizeError:

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

  103.             break;

  104.         case kAudioConverterErr_RequiresPacketDescriptionsError:

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

  106.             break;

  107.         case kAudioConverterErr_InputSampleRateOutOfRange:

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

  109.             break;

  110.         case kAudioConverterErr_OutputSampleRateOutOfRange:

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

  112.             break;

  113.         case kAudioHardwareNotRunningError:

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

  115.             break;

  116.         case kAudioHardwareUnknownPropertyError:

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

  118.             break;

  119.         case kAudioHardwareIllegalOperationError:

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

  121.             break;

  122.         case kAudioHardwareBadDeviceError:

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

  124.             break;

  125.         case kAudioHardwareBadStreamError:

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

  127.             break;

  128.         case kAudioDeviceUnsupportedFormatError:

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

  130.             break;

  131.         case kAudioDevicePermissionsError:

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

  133.             break;

  134.         case kAudioHardwareBadObjectError:

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

  136.             break;

  137.         case kAudioHardwareUnsupportedOperationError:

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

  139.             break;

  140.         default:

  141.             jack_log("error code : unknown");

  142.             break;

  143.     }

  144. }

  145. 

  146. OSStatus JackCoreAudioAdapter::SRNotificationCallback(AudioDeviceID inDevice,

  147.                                                         UInt32 inChannel,

  148.                                                         Boolean	isInput,

  149.                                                         AudioDevicePropertyID inPropertyID,

  150.                                                         void* inClientData)

  151. {

  152.     JackCoreAudioAdapter* driver = static_cast<JackCoreAudioAdapter*>(inClientData);

  153. 

  154.     switch (inPropertyID) {

  155. 

  156.         case kAudioDevicePropertyNominalSampleRate: {

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

  158.             driver->fState = true;

  159.             break;

  160.         }

  161.     }

  162. 

  163.     return noErr;

  164. }

  165. 

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

  167. OSStatus JackCoreAudioAdapter::DeviceNotificationCallback(AudioDeviceID inDevice,

  168.         UInt32 inChannel,

  169.         Boolean	isInput,

  170.         AudioDevicePropertyID inPropertyID,

  171.         void* inClientData)

  172. {

  173.         

  174.     switch (inPropertyID) {

  175.         

  176.         case kAudioDeviceProcessorOverload: {

  177.             jack_error("JackCoreAudioAdapter::DeviceNotificationCallback kAudioDeviceProcessorOverload");

  178.             break;

  179. 		}

  180. 

  181.         case kAudioDevicePropertyStreamConfiguration: {

  182.             jack_error("Cannot handle kAudioDevicePropertyStreamConfiguration");

  183.             return kAudioHardwareUnsupportedOperationError;

  184.         }

  185.             

  186.         case kAudioDevicePropertyNominalSampleRate: {

  187.             jack_error("Cannot handle kAudioDevicePropertyNominalSampleRate");

  188.             return kAudioHardwareUnsupportedOperationError;

  189.         }

  190.             

  191.     }

  192.     return noErr;

  193. }

  194. 

  195. int JackCoreAudioAdapter::AddListeners()

  196. {

  197.     OSStatus err = noErr;

  198. 

  199.     // Add listeners

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

  201.     if (err != noErr) {

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

  203.         printError(err);

  204.         return -1;

  205.     }

  206.     

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

  208.     if (err != noErr) {

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

  210.         printError(err);

  211.         return -1;

  212.     }

  213. 

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

  215.     if (err != noErr) {

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

  217.         printError(err);

  218.         return -1;

  219.     }

  220. 

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

  222.     if (err != noErr) {

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

  224.         printError(err);

  225.         return -1;

  226.     }

  227. 

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

  229.     if (err != noErr) {

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

  231.         printError(err);

  232.         return -1;

  233.     }

  234. 

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

  236.     if (err != noErr) {

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

  238.         printError(err);

  239.         return -1;

  240.     }

  241. 

  242.     return 0;

  243. }

  244. 

  245. void JackCoreAudioAdapter::RemoveListeners()

  246. {

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

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

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

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

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

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

  253. }

  254. 

  255. OSStatus JackCoreAudioAdapter::Render(void *inRefCon,

  256.                                         AudioUnitRenderActionFlags *ioActionFlags,

  257.                                         const AudioTimeStamp *inTimeStamp,

  258.                                         UInt32 inBusNumber,

  259.                                         UInt32 inNumberFrames,

  260.                                         AudioBufferList *ioData)

  261. {

  262.     JackCoreAudioAdapter* adapter = static_cast<JackCoreAudioAdapter*>(inRefCon);

  263.     AudioUnitRender(adapter->fAUHAL, ioActionFlags, inTimeStamp, 1, inNumberFrames, adapter->fInputData);

  264.     

  265.     float* inputBuffer[adapter->fCaptureChannels];

  266.     float* outputBuffer[adapter->fPlaybackChannels];

  267.  

  268.     for (int i = 0; i < adapter->fCaptureChannels; i++) {

  269.         inputBuffer[i] = (float*)adapter->fInputData->mBuffers[i].mData;

  270.     }

  271.     for (int i = 0; i < adapter->fPlaybackChannels; i++) {

  272.         outputBuffer[i] = (float*)ioData->mBuffers[i].mData;

  273.     }

  274.     

  275.     adapter->PushAndPull((float**)inputBuffer, (float**)outputBuffer, inNumberFrames);

  276.     return noErr;

  277. }

  278. 

  279. JackCoreAudioAdapter::JackCoreAudioAdapter(jack_nframes_t buffer_size, jack_nframes_t sample_rate, const JSList* params)

  280.                 :JackAudioAdapterInterface(buffer_size, sample_rate), fInputData(0), fCapturing(false), fPlaying(false), fState(false)

  281. {

  282. 

  283.     const JSList* node;

  284.     const jack_driver_param_t* param;

  285.    

  286.     char captureName[256];

  287.     char playbackName[256];

  288.         

  289.     fCaptureUID[0] = 0;

  290.     fPlaybackUID[0] = 0;

  291.     

  292.     // Default values

  293.     fCaptureChannels = 0;

  294.     fPlaybackChannels = 0;

  295.   

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

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

  298. 

  299.         switch (param->character) {

  300. 

  301.             case 'c' :

  302.                 fCaptureChannels = fPlaybackChannels = param->value.ui;

  303.                 break;

  304. 

  305.             case 'i':

  306.                 fCaptureChannels = param->value.ui;

  307.                 break;

  308. 

  309.             case 'o':

  310.                 fPlaybackChannels = param->value.ui;

  311.                 break;

  312. 

  313.             case 'C':

  314.                 fCapturing = true;

  315.                 strncpy(fCaptureUID, param->value.str, 256);

  316.                 break;

  317. 

  318.             case 'P':

  319.                 fPlaying = true;

  320.                 strncpy(fPlaybackUID, param->value.str, 256);

  321.                 break;

  322.                 

  323.             case 'd':

  324.                 strncpy(fCaptureUID, param->value.str, 256);

  325.                 strncpy(fPlaybackUID, param->value.str, 256);

  326.                 break;

  327. 

  328.             case 'D':

  329.                 fCapturing = fPlaying = true;

  330.                 break;

  331. 

  332.             case 'r':

  333.                 SetAdaptedSampleRate(param->value.ui);

  334.                 break;

  335. 

  336.             case 'p':

  337.                 SetAdaptedBufferSize(param->value.ui);

  338.                 break;

  339.                 

  340.             case 'l':

  341.                 DisplayDeviceNames();

  342.                 break;

  343.                 

  344.             case 'q':

  345.                 fQuality = param->value.ui;

  346.                 break;

  347.                 

  348.             case 'g':

  349.                 fRingbufferCurSize = param->value.ui;

  350.                 fAdaptative = false;

  351.                 break;

  352.         }

  353.     }

  354.     

  355.     /* duplex is the default */

  356.     if (!fCapturing && !fPlaying) {

  357.         fCapturing = true;

  358.         fPlaying = true;

  359.     }

  360.      

  361.     int in_nChannels = 0;

  362.     int out_nChannels = 0;

  363.     

  364.     if (SetupDevices(fCaptureUID, fPlaybackUID, captureName, playbackName) < 0)

  365.         throw -1;

  366.   

  367.     if (SetupChannels(fCapturing, fPlaying, fCaptureChannels, fPlaybackChannels, in_nChannels, out_nChannels, true) < 0)

  368.         throw -1;

  369.  

  370.     if (SetupBufferSizeAndSampleRate(fAdaptedBufferSize, fAdaptedSampleRate) < 0)

  371.         throw -1;

  372. 

  373.     if (fCapturing && fCaptureChannels > 0)

  374.         if (SetupBuffers(fCaptureChannels) < 0)

  375.             throw -1;

  376.             

  377.     if (OpenAUHAL(fCapturing, fPlaying, fCaptureChannels, fPlaybackChannels, in_nChannels, out_nChannels, fAdaptedBufferSize, fAdaptedSampleRate, true) < 0)

  378.         throw -1;

  379.         

  380.     if (AddListeners() < 0)

  381.         throw -1;

  382. }

  383. 

  384. OSStatus JackCoreAudioAdapter::GetDefaultDevice(AudioDeviceID* id)

  385. {

  386.     OSStatus res;

  387.     UInt32 theSize = sizeof(UInt32);

  388.     AudioDeviceID inDefault;

  389.     AudioDeviceID outDefault;

  390. 

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

  392.         return res;

  393. 

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

  395.         return res;

  396. 

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

  398. 

  399.     // Get the device only if default input and ouput are the same

  400.     if (inDefault == outDefault) {

  401.         *id = inDefault;

  402.         return noErr;

  403.     } else {

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

  405.         return kAudioHardwareBadDeviceError;

  406.     }

  407. }

  408. 

  409. OSStatus JackCoreAudioAdapter::GetTotalChannels(AudioDeviceID device, int& channelCount, bool isInput)

  410. {

  411.     OSStatus err = noErr;

  412.     UInt32	outSize;

  413.     Boolean	outWritable;

  414.     AudioBufferList* bufferList = 0;

  415. 

  416.     channelCount = 0;

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

  418.     if (err == noErr) {

  419.         bufferList = (AudioBufferList*)malloc(outSize);

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

  421.         if (err == noErr) {

  422.             for (unsigned int i = 0; i < bufferList->mNumberBuffers; i++)

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

  424.         }

  425. 

  426.         if (bufferList)

  427.             free(bufferList);

  428.     }

  429. 

  430.     return err;

  431. }

  432. 

  433. OSStatus JackCoreAudioAdapter::GetDeviceIDFromUID(const char* UID, AudioDeviceID* id)

  434. {

  435.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  438. 

  439.     if (inIUD == NULL) {

  440.         return kAudioHardwareUnspecifiedError;

  441.     } else {

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

  443.         CFRelease(inIUD);

  444.         jack_log("GetDeviceIDFromUID %s %ld", UID, *id);

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

  446.     }

  447. }

  448. 

  449. OSStatus JackCoreAudioAdapter::GetDefaultInputDevice(AudioDeviceID* id)

  450. {

  451.     OSStatus res;

  452.     UInt32 theSize = sizeof(UInt32);

  453.     AudioDeviceID inDefault;

  454. 

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

  456.         return res;

  457. 

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

  459.     *id = inDefault;

  460.     return noErr;

  461. }

  462. 

  463. OSStatus JackCoreAudioAdapter::GetDefaultOutputDevice(AudioDeviceID* id)

  464. {

  465.     OSStatus res;

  466.     UInt32 theSize = sizeof(UInt32);

  467.     AudioDeviceID outDefault;

  468. 

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

  470.         return res;

  471. 

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

  473.     *id = outDefault;

  474.     return noErr;

  475. }

  476. 

  477. OSStatus JackCoreAudioAdapter::GetDeviceNameFromID(AudioDeviceID id, char* name)

  478. {

  479.     UInt32 size = 256;

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

  481. }

  482. 

  483. // Setup

  484. int JackCoreAudioAdapter::SetupDevices(const char* capture_driver_uid,

  485.                                         const char* playback_driver_uid,

  486.                                         char* capture_driver_name,

  487.                                         char* playback_driver_name)

  488. {

  489.     capture_driver_name[0] = 0;

  490.     playback_driver_name[0] = 0;

  491. 

  492.     // Duplex

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

  494.     

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

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

  497.             

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

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

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

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

  502.                     return -1;

  503.                 }

  504.             }

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

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

  507.                 return -1;

  508.             }

  509.             

  510.         } else {

  511.         

  512.             // Creates aggregate device

  513.             AudioDeviceID captureID, playbackID;

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

  515.                 return -1;

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

  517.                 return -1;

  518.             if (CreateAggregateDevice(captureID, playbackID, &fDeviceID) != noErr)

  519.                 return -1;

  520.         }

  521. 

  522.     // Capture only

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

  524.         jack_log("JackCoreAudioAdapter::Open capture only");

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

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

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

  528.                 return -1;

  529.             }

  530.         }

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

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

  533.             return -1;

  534.         }

  535. 

  536.     // Playback only

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

  538.         jack_log("JackCoreAudioAdapter::Open playback only");

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

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

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

  542.                 return -1;

  543.             }

  544.         }

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

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

  547.             return -1;

  548.         }

  549. 

  550.     // Use default driver in duplex mode

  551.     } else {

  552.         jack_log("JackCoreAudioAdapter::Open default driver");

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

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

  555.             return -1;

  556.         }

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

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

  559.             return -1;

  560.         }

  561.     }

  562. 

  563.     return 0;

  564. }

  565. 

  566. int JackCoreAudioAdapter::SetupChannels(bool capturing,

  567.                                         bool playing,

  568.                                         int& inchannels,

  569.                                         int& outchannels,

  570.                                         int& in_nChannels,

  571.                                         int& out_nChannels,

  572.                                         bool strict)

  573. {

  574.     OSStatus err = noErr;

  575. 

  576.     if (capturing) {

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

  578.         if (err != noErr) {

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

  580.             printError(err);

  581.             return -1;

  582.         } else {

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

  584.         }

  585.     }

  586. 

  587.     if (playing) {

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

  589.         if (err != noErr) {

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

  591.             printError(err);

  592.             return -1;

  593.         } else {

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

  595.         }

  596.     }

  597. 

  598.     if (inchannels > in_nChannels) {

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

  600.         if (strict)

  601.             return -1;

  602.     }

  603. 

  604.     if (outchannels > out_nChannels) {

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

  606.         if (strict)

  607.             return -1;

  608.     }

  609. 

  610.     if (inchannels == 0) {

  611.         jack_log("Setup max in channels = %ld", in_nChannels);

  612.         inchannels = in_nChannels;

  613.     }

  614. 

  615.     if (outchannels == 0) {

  616.         jack_log("Setup max out channels = %ld", out_nChannels);

  617.         outchannels = out_nChannels;

  618.     }

  619. 

  620.     return 0;

  621. }

  622. 

  623. int JackCoreAudioAdapter::SetupBufferSizeAndSampleRate(jack_nframes_t nframes, jack_nframes_t samplerate)

  624. {

  625.     OSStatus err = noErr;

  626.     UInt32 outSize;

  627.     Float64 sampleRate;

  628. 

  629.     // Setting buffer size

  630.     outSize = sizeof(UInt32);

  631.     err = AudioDeviceSetProperty(fDeviceID, NULL, 0, false, kAudioDevicePropertyBufferFrameSize, outSize, &nframes);

  632.     if (err != noErr) {

  633.         jack_error("Cannot set buffer size %ld", nframes);

  634.         printError(err);

  635.         return -1;

  636.     }

  637. 

  638.     // Get sample rate

  639.     outSize =  sizeof(Float64);

  640.     err = AudioDeviceGetProperty(fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);

  641.     if (err != noErr) {

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

  643.         printError(err);

  644.         return -1;

  645.     }

  646. 

  647.     // If needed, set new sample rate

  648.     if (samplerate != (jack_nframes_t)sampleRate) {

  649.         sampleRate = (Float64)samplerate;

  650. 

  651.         // To get SR change notification

  652.         err = AudioDeviceAddPropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback, this);

  653.         if (err != noErr) {

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

  655.             printError(err);

  656.             return -1;

  657.         }

  658.         err = AudioDeviceSetProperty(fDeviceID, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, outSize, &sampleRate);

  659.         if (err != noErr) {

  660.             jack_error("Cannot set sample rate = %ld", samplerate);

  661.             printError(err);

  662.             return -1;

  663.         }

  664. 

  665.         // Waiting for SR change notification

  666.         int count = 0;

  667.         while (!fState && count++ < 100) {

  668.             usleep(100000);

  669.             jack_log("Wait count = %ld", count);

  670.         }

  671. 

  672.         // Remove SR change notification

  673.         AudioDeviceRemovePropertyListener(fDeviceID, 0, true, kAudioDevicePropertyNominalSampleRate, SRNotificationCallback);

  674.     }

  675. 

  676.     return 0;

  677. }

  678. 

  679. int JackCoreAudioAdapter::SetupBuffers(int inchannels)

  680. {

  681.     jack_log("JackCoreAudioAdapter::SetupBuffers: input = %ld", inchannels);

  682. 

  683.     // Prepare buffers

  684.     fInputData = (AudioBufferList*)malloc(sizeof(UInt32) + inchannels * sizeof(AudioBuffer));

  685.     if (fInputData == 0) {

  686.         jack_error("Cannot allocate memory for input buffers");

  687.         return -1;

  688.     }

  689.     fInputData->mNumberBuffers = inchannels;

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

  691.         fInputData->mBuffers[i].mNumberChannels = 1;

  692.         fInputData->mBuffers[i].mDataByteSize = fAdaptedBufferSize * sizeof(float);

  693.         fInputData->mBuffers[i].mData = malloc(fAdaptedBufferSize * sizeof(float));

  694.     }

  695.     return 0;

  696. }

  697. 

  698. void JackCoreAudioAdapter::DisposeBuffers()

  699. {

  700.     if (fInputData) {

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

  702.             free(fInputData->mBuffers[i].mData);

  703.         free(fInputData);

  704.         fInputData = 0;

  705.     }

  706. }

  707. 

  708. int JackCoreAudioAdapter::OpenAUHAL(bool capturing,

  709.                                     bool playing,

  710.                                     int inchannels,

  711.                                     int outchannels,

  712.                                     int in_nChannels,

  713.                                     int out_nChannels,

  714.                                     jack_nframes_t buffer_size,

  715.                                     jack_nframes_t samplerate,

  716.                                     bool strict)

  717. {

  718.     ComponentResult err1;

  719.     UInt32 enableIO;

  720.     AudioStreamBasicDescription srcFormat, dstFormat;

  721. 

  722.     jack_log("OpenAUHAL capturing = %ld playing = %ld inchannels = %ld outchannels = %ld in_nChannels = %ld out_nChannels = %ld ", capturing, playing, inchannels, outchannels, in_nChannels, out_nChannels);

  723. 

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

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

  726.         return -1;

  727.     }

  728.          

  729.     // AUHAL

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

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

  732. 

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

  734.     if (err1 != noErr) {

  735.         jack_error("Error calling OpenAComponent");

  736.         printError(err1);

  737.         return -1;

  738.     }

  739. 

  740.     err1 = AudioUnitInitialize(fAUHAL);

  741.     if (err1 != noErr) {

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

  743.         printError(err1);

  744.         return -1;

  745.     }

  746. 

  747.     // Start I/O

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

  749.         enableIO = 1;

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

  751.     } else {

  752.         enableIO = 0;

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

  754.     }

  755.     

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

  757.     if (err1 != noErr) {

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

  759.         printError(err1);

  760.         if (strict)

  761.             return -1;

  762.     }

  763. 

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

  765.         enableIO = 1;

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

  767.     } else {

  768.         enableIO = 0;

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

  770.     }

  771.     

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

  773.     if (err1 != noErr) {

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

  775.         printError(err1);

  776.         if (strict)

  777.             return -1;

  778.     }

  779.     

  780.     AudioDeviceID currAudioDeviceID;

  781.     UInt32 size = sizeof(AudioDeviceID);

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

  783.     if (err1 != noErr) {

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

  785.         printError(err1);

  786.         if (strict)

  787.             return -1;

  788.     } else {

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

  790.     }

  791. 

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

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

  794.     if (err1 != noErr) {

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

  796.         printError(err1);

  797.         if (strict)

  798.             return -1;

  799.     }

  800.     

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

  802.     if (err1 != noErr) {

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

  804.         printError(err1);

  805.         if (strict)

  806.             return -1;

  807.     } else {

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

  809.     }

  810. 

  811.     // Set buffer size

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

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

  814.         if (err1 != noErr) {

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

  816.             printError(err1);

  817.             if (strict)

  818.                 return -1;

  819.         }

  820.     }

  821. 

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

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

  824.         if (err1 != noErr) {

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

  826.             printError(err1);

  827.             if (strict)

  828.                 return -1;

  829.         }

  830.     }

  831. 

  832.     // Setup channel map

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

  834.         SInt32 chanArr[in_nChannels];

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

  836.             chanArr[i] = -1;

  837.         }

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

  839.             chanArr[i] = i;

  840.         }

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

  842.         if (err1 != noErr) {

  843.             jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap 1");

  844.             printError(err1);

  845.         }

  846.     }

  847. 

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

  849.         SInt32 chanArr[out_nChannels];

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

  851.             chanArr[i] = -1;

  852.         }

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

  854.             chanArr[i] = i;

  855.         }

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

  857.         if (err1 != noErr) {

  858.             jack_error("Error calling AudioUnitSetProperty - kAudioOutputUnitProperty_ChannelMap 0");

  859.             printError(err1);

  860.         }

  861.     }

  862. 

  863.     // Setup stream converters

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

  865.     srcFormat.mSampleRate = samplerate;

  866.     srcFormat.mFormatID = kAudioFormatLinearPCM;

  867.     srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  868.     srcFormat.mBytesPerPacket = sizeof(float);

  869.     srcFormat.mFramesPerPacket = 1;

  870.     srcFormat.mBytesPerFrame = sizeof(float);

  871.     srcFormat.mChannelsPerFrame = outchannels;

  872.     srcFormat.mBitsPerChannel = 32;

  873. 

  874.     err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &srcFormat, sizeof(AudioStreamBasicDescription));

  875.     if (err1 != noErr) {

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

  877.         printError(err1);

  878.     }

  879. 

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

  881.     dstFormat.mSampleRate = samplerate;

  882.     dstFormat.mFormatID = kAudioFormatLinearPCM;

  883.     dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  884.     dstFormat.mBytesPerPacket = sizeof(float);

  885.     dstFormat.mFramesPerPacket = 1;

  886.     dstFormat.mBytesPerFrame = sizeof(float);

  887.     dstFormat.mChannelsPerFrame = inchannels;

  888.     dstFormat.mBitsPerChannel = 32;

  889. 

  890.     err1 = AudioUnitSetProperty(fAUHAL, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &dstFormat, sizeof(AudioStreamBasicDescription));

  891.     if (err1 != noErr) {

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

  893.         printError(err1);

  894.     }

  895. 

  896.     // Setup callbacks

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

  898.         AURenderCallbackStruct output;

  899.         output.inputProc = Render;

  900.         output.inputProcRefCon = this;

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

  902.         if (err1 != noErr) {

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

  904.             printError(err1);

  905.             return -1;

  906.         }

  907.     } else {

  908.         AURenderCallbackStruct output;

  909.         output.inputProc = Render;

  910.         output.inputProcRefCon = this;

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

  912.         if (err1 != noErr) {

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

  914.             printError(err1);

  915.             return -1;

  916.         }

  917.     }

  918. 

  919.     return 0;

  920. }

  921. 

  922. OSStatus JackCoreAudioAdapter::DestroyAggregateDevice() 

  923. {

  924.     OSStatus osErr = noErr;

  925.     AudioObjectPropertyAddress pluginAOPA;

  926.     pluginAOPA.mSelector = kAudioPlugInDestroyAggregateDevice;

  927.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  928.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  929.     UInt32 outDataSize;

  930.   

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

  932.     if (osErr != noErr) {

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

  934.         printError(osErr);

  935.         return osErr;

  936.     }

  937.         

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

  939.     if (osErr != noErr) {

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

  941.         printError(osErr);

  942.         return osErr;

  943.     }

  944.     

  945.     return noErr;

  946. }

  947. 

  948. static CFStringRef GetDeviceName(AudioDeviceID id)

  949. {

  950.     UInt32 size = sizeof(CFStringRef);

  951.     CFStringRef UIname;

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

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

  954. }

  955. 

  956. OSStatus JackCoreAudioAdapter::CreateAggregateDevice(AudioDeviceID captureDeviceID, AudioDeviceID playbackDeviceID, AudioDeviceID* outAggregateDevice) 

  957. {

  958.     OSStatus osErr = noErr;

  959.     UInt32 outSize;

  960.     Boolean outWritable;

  961. 

  962.     //---------------------------------------------------------------------------

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

  964.     //---------------------------------------------------------------------------

  965.     

  966.     jack_info("Separated input and output devices, so create a private aggregate device to handle them...");

  967.  

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

  969.     if (osErr != noErr) 

  970.         return osErr;

  971. 

  972.     AudioValueTranslation pluginAVT;

  973. 

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

  975.    

  976.     pluginAVT.mInputData = &inBundleRef;

  977.     pluginAVT.mInputDataSize = sizeof(inBundleRef);

  978.     pluginAVT.mOutputData = &fPluginID;

  979.     pluginAVT.mOutputDataSize = sizeof(fPluginID);

  980. 

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

  982.     if (osErr != noErr) 

  983.         return osErr;

  984. 

  985.     //-------------------------------------------------

  986.     // Create a CFDictionary for our aggregate device

  987.     //-------------------------------------------------

  988. 

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

  990. 

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

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

  993.     

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

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

  996. 

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

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

  999.     

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

  1001.     int value = 1;

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

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

  1004.   

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

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

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

  1008.     

  1009.     CFStringRef captureDeviceUID = GetDeviceName(captureDeviceID);

  1010.     CFStringRef playbackDeviceUID = GetDeviceName(playbackDeviceID);

  1011.     

  1012.     if (captureDeviceUID == NULL || playbackDeviceUID == NULL)

  1013.         return -1;

  1014.   

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

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

  1017. 

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

  1019.     CFArrayAppendValue(subDevicesArray, captureDeviceUID);

  1020.     CFArrayAppendValue(subDevicesArray, playbackDeviceUID);

  1021. 

  1022.     //-----------------------------------------------------------------------

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

  1024.     //-----------------------------------------------------------------------

  1025.  

  1026.     AudioObjectPropertyAddress pluginAOPA;

  1027.     pluginAOPA.mSelector = kAudioPlugInCreateAggregateDevice;

  1028.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1029.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1030.     UInt32 outDataSize;

  1031. 

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

  1033.     if (osErr != noErr) 

  1034.         return osErr;

  1035. 

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

  1037.     if (osErr != noErr) 

  1038.         return osErr;

  1039. 

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

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

  1042.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1043. 

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

  1045.     // Set the sub-device list

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

  1047. 

  1048.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyFullSubDeviceList;

  1049.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1050.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1051.     outDataSize = sizeof(CFMutableArrayRef);

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

  1053.     if (osErr != noErr)

  1054.         return osErr;

  1055. 

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

  1057.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1058. 

  1059.     //-----------------------

  1060.     // Set the master device

  1061.     //-----------------------

  1062. 

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

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

  1065.     pluginAOPA.mSelector = kAudioAggregateDevicePropertyMasterSubDevice;

  1066.     pluginAOPA.mScope = kAudioObjectPropertyScopeGlobal;

  1067.     pluginAOPA.mElement = kAudioObjectPropertyElementMaster;

  1068.     outDataSize = sizeof(CFStringRef);

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

  1070.     if (osErr != noErr) 

  1071.         return osErr;

  1072. 

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

  1074.     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);

  1075. 

  1076.     //----------

  1077.     // Clean up

  1078.     //----------

  1079.     

  1080.     CFRelease(AggregateDeviceNumberRef);

  1081. 

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

  1083.     CFRelease(aggDeviceDict);

  1084.     CFRelease(subDevicesArray);

  1085. 

  1086.     // release the device UID

  1087.     CFRelease(captureDeviceUID);

  1088.     CFRelease(playbackDeviceUID);

  1089.     

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

  1091.     return noErr;

  1092. }

  1093. 

  1094. void JackCoreAudioAdapter::CloseAUHAL()

  1095. {

  1096.     AudioUnitUninitialize(fAUHAL);

  1097.     CloseComponent(fAUHAL);

  1098. }

  1099. 

  1100. int JackCoreAudioAdapter::Open()

  1101. {

  1102.     return (AudioOutputUnitStart(fAUHAL) != noErr)  ? -1 : 0;

  1103. }

  1104. 

  1105. int JackCoreAudioAdapter::Close()

  1106. {

  1107. #ifdef JACK_MONITOR

  1108.     fTable.Save(fHostBufferSize, fHostSampleRate, fAdaptedSampleRate, fAdaptedBufferSize);

  1109. #endif

  1110.     AudioOutputUnitStop(fAUHAL);

  1111.     DisposeBuffers();

  1112.     CloseAUHAL();

  1113.     RemoveListeners();

  1114.     if (fPluginID > 0)

  1115.         DestroyAggregateDevice();

  1116.     return 0;

  1117. }

  1118. 

  1119. int JackCoreAudioAdapter::SetSampleRate ( jack_nframes_t sample_rate ) {

  1120.     JackAudioAdapterInterface::SetHostSampleRate ( sample_rate );

  1121.     Close();

  1122.     return Open();

  1123. }

  1124. 

  1125. int JackCoreAudioAdapter::SetBufferSize ( jack_nframes_t buffer_size ) {

  1126.     JackAudioAdapterInterface::SetHostBufferSize ( buffer_size );

  1127.     Close();

  1128.     return Open();

  1129. }

  1130. 

  1131. } // namespace

  1132. 

  1133. #ifdef __cplusplus

  1134. extern "C"

  1135. {

  1136. #endif

  1137. 

  1138.    SERVER_EXPORT jack_driver_desc_t* jack_get_descriptor()

  1139.    {

  1140.         jack_driver_desc_t *desc;

  1141.         unsigned int i;

  1142.         desc = (jack_driver_desc_t*)calloc(1, sizeof(jack_driver_desc_t));

  1143. 

  1144.         strcpy(desc->name, "audioadapter");                            // size MUST be less then JACK_DRIVER_NAME_MAX + 1

  1145.         strcpy(desc->desc, "netjack audio <==> net backend adapter");  // size MUST be less then JACK_DRIVER_PARAM_DESC + 1

  1146.      

  1147.         desc->nparams = 12;

  1148.         desc->params = (jack_driver_param_desc_t*)calloc(desc->nparams, sizeof(jack_driver_param_desc_t));

  1149. 

  1150.         i = 0;

  1151.         strcpy(desc->params[i].name, "channels");

  1152.         desc->params[i].character = 'c';

  1153.         desc->params[i].type = JackDriverParamInt;

  1154.         desc->params[i].value.ui = 0;

  1155.         strcpy(desc->params[i].short_desc, "Maximum number of channels");

  1156.         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1157. 

  1158.         i++;

  1159.         strcpy(desc->params[i].name, "inchannels");

  1160.         desc->params[i].character = 'i';

  1161.         desc->params[i].type = JackDriverParamInt;

  1162.         desc->params[i].value.ui = 0;

  1163.         strcpy(desc->params[i].short_desc, "Maximum number of input channels");

  1164.         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1165. 

  1166.         i++;

  1167.         strcpy(desc->params[i].name, "outchannels");

  1168.         desc->params[i].character = 'o';

  1169.         desc->params[i].type = JackDriverParamInt;

  1170.         desc->params[i].value.ui = 0;

  1171.         strcpy(desc->params[i].short_desc, "Maximum number of output channels");

  1172.         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1173. 

  1174.         i++;

  1175.         strcpy(desc->params[i].name, "capture");

  1176.         desc->params[i].character = 'C';

  1177.         desc->params[i].type = JackDriverParamString;

  1178.         strcpy(desc->params[i].value.str, "will take default CoreAudio input device");

  1179.         strcpy(desc->params[i].short_desc, "Provide capture ports. Optionally set CoreAudio device name");

  1180.         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1181. 

  1182.         i++;

  1183.         strcpy(desc->params[i].name, "playback");

  1184.         desc->params[i].character = 'P';

  1185.         desc->params[i].type = JackDriverParamString;

  1186.         strcpy(desc->params[i].value.str, "will take default CoreAudio output device");

  1187.         strcpy(desc->params[i].short_desc, "Provide playback ports. Optionally set CoreAudio device name");

  1188.         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1189. 

  1190.         i++;

  1191.         strcpy(desc->params[i].name, "rate");

  1192.         desc->params[i].character = 'r';

  1193.         desc->params[i].type = JackDriverParamUInt;

  1194.         desc->params[i].value.ui = 44100U;

  1195.         strcpy(desc->params[i].short_desc, "Sample rate");

  1196.         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1197. 

  1198.         i++;

  1199.         strcpy(desc->params[i].name, "periodsize");

  1200.         desc->params[i].character = 'p';

  1201.         desc->params[i].type = JackDriverParamUInt;

  1202.         desc->params[i].value.ui = 512U;

  1203.         strcpy(desc->params[i].short_desc, "Period size");

  1204.         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1205. 

  1206.         i++;

  1207.         strcpy(desc->params[i].name, "duplex");

  1208.         desc->params[i].character = 'D';

  1209.         desc->params[i].type = JackDriverParamBool;

  1210.         desc->params[i].value.i = TRUE;

  1211.         strcpy(desc->params[i].short_desc, "Provide both capture and playback ports");

  1212.         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1213. 

  1214.         i++;

  1215.         strcpy(desc->params[i].name, "device");

  1216.         desc->params[i].character = 'd';

  1217.         desc->params[i].type = JackDriverParamString;

  1218.         strcpy(desc->params[i].value.str, "will take default CoreAudio device name");

  1219.         strcpy(desc->params[i].short_desc, "CoreAudio device name");

  1220.         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1221. 

  1222.         i++;

  1223.         strcpy(desc->params[i].name, "list-devices");

  1224.         desc->params[i].character = 'l';

  1225.         desc->params[i].type = JackDriverParamBool;

  1226.         desc->params[i].value.i = TRUE;

  1227.         strcpy(desc->params[i].short_desc, "Display available CoreAudio devices");

  1228.         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1229.         

  1230.         i++;

  1231.         strcpy(desc->params[i].name, "quality");

  1232.         desc->params[i].character = 'q';

  1233.         desc->params[i].type = JackDriverParamInt;

  1234.         desc->params[i].value.ui = 0;

  1235.         strcpy(desc->params[i].short_desc, "Resample algorithm quality (0 - 4)");

  1236.         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);

  1237.         

  1238.         i++;

  1239.         strcpy(desc->params[i].name, "ring-buffer");

  1240.         desc->params[i].character = 'g';

  1241.         desc->params[i].type = JackDriverParamInt;

  1242.         desc->params[i].value.ui = 32768;

  1243.         strcpy(desc->params[i].short_desc, "Fixed ringbuffer size");

  1244.         strcpy(desc->params[i].long_desc, "Fixed ringbuffer size (if not set => automatic adaptative)");

  1245. 

  1246.         return desc;

  1247.     }

  1248. 

  1249. 

  1250. #ifdef __cplusplus

  1251. }

  1252. #endif