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

1371 lines
51KB
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 "JackCompilerDeps.h"

  29. #include <iostream>

  30. 

  31. namespace Jack

  32. {

  33. 

  34. static void printError(OSStatus err)

  35. {

  36.     switch (err) {

  37.         case kAudioHardwareNoError:

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

  39.             break;

  40.         case kAudioConverterErr_FormatNotSupported:

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

  42.             break;

  43.         case kAudioConverterErr_OperationNotSupported:

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

  45.             break;

  46.         case kAudioConverterErr_PropertyNotSupported:

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

  48.             break;

  49.         case kAudioConverterErr_InvalidInputSize:

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

  51.             break;

  52.         case kAudioConverterErr_InvalidOutputSize:

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

  54.             break;

  55.         case kAudioConverterErr_UnspecifiedError:

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

  57.             break;

  58.         case kAudioConverterErr_BadPropertySizeError:

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

  60.             break;

  61.         case kAudioConverterErr_RequiresPacketDescriptionsError:

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

  63.             break;

  64.         case kAudioConverterErr_InputSampleRateOutOfRange:

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

  66.             break;

  67.         case kAudioConverterErr_OutputSampleRateOutOfRange:

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

  69.             break;

  70.         case kAudioHardwareNotRunningError:

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

  72.             break;

  73.         case kAudioHardwareUnknownPropertyError:

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

  75.             break;

  76.         case kAudioHardwareIllegalOperationError:

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

  78.             break;

  79.         case kAudioHardwareBadDeviceError:

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

  81.             break;

  82.         case kAudioHardwareBadStreamError:

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

  84.             break;

  85.         case kAudioDeviceUnsupportedFormatError:

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

  87.             break;

  88.         case kAudioDevicePermissionsError:

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

  90.             break;

  91.         case kAudioHardwareBadObjectError:

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

  93.             break;

  94.         case kAudioHardwareUnsupportedOperationError:

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

  96.             break;

  97.         default:

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

  99.             break;

  100.     }

  101. }

  102. 

  103. static OSStatus DisplayDeviceNames()

  104. {

  105.     UInt32 size;

  106.     Boolean isWritable;

  107.     int i, deviceNum;

  108.     OSStatus err;

  109.     CFStringRef UIname;

  110. 

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

  112.     if (err != noErr)

  113.         return err;

  114. 

  115.     deviceNum = size / sizeof(AudioDeviceID);

  116.     AudioDeviceID devices[deviceNum];

  117. 

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

  119.     if (err != noErr)

  120.         return err;

  121. 

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

  123.         char device_name[256];

  124.         char internal_name[256];

  125. 

  126.         size = sizeof(CFStringRef);

  127.         UIname = NULL;

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

  129.         if (err == noErr) {

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

  131.         } else {

  132.             goto error;

  133.         }

  134. 

  135.         size = 256;

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

  137.         if (err != noErr)

  138.             return err;

  139. 

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

  141.     }

  142. 

  143.     return noErr;

  144. 

  145. error:

  146.     if (UIname != NULL)

  147.         CFRelease(UIname);

  148.     return err;

  149. }

  150. 

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

  152.                                      AudioUnitRenderActionFlags *ioActionFlags,

  153.                                      const AudioTimeStamp *inTimeStamp,

  154.                                      UInt32 inBusNumber,

  155.                                      UInt32 inNumberFrames,

  156.                                      AudioBufferList *ioData)

  157. {

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

  159.     driver->fActionFags = ioActionFlags;

  160.     driver->fCurrentTime = (AudioTimeStamp *)inTimeStamp;

  161.     driver->fDriverOutputData = ioData;

  162.     driver->CycleTakeBeginTime();

  163.     return driver->Process();

  164. }

  165. 

  166. int JackCoreAudioDriver::Read()

  167. {

  168.     AudioUnitRender(fAUHAL, fActionFags, fCurrentTime, 1, fEngineControl->fBufferSize, fJackInputData);

  169.     return 0;

  170. }

  171. 

  172. int JackCoreAudioDriver::Write()

  173. {

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

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

  176.             float* buffer = GetOutputBuffer(i);

  177.             int size = sizeof(float) * fEngineControl->fBufferSize;

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

  179.             // Monitor ports

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

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

  182.         } else {

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

  184.         }

  185.     }

  186.     return 0;

  187. }

  188. 

  189. // Will run only once

  190. OSStatus JackCoreAudioDriver::MeasureCallback(AudioDeviceID inDevice,

  191.         const AudioTimeStamp* inNow,

  192.         const AudioBufferList* inInputData,

  193.         const AudioTimeStamp* inInputTime,

  194.         AudioBufferList* outOutputData,

  195.         const AudioTimeStamp* inOutputTime,

  196.         void* inClientData)

  197. {

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

  199.     AudioDeviceStop(driver->fDeviceID, MeasureCallback);

  200.     

  201.     jack_log("JackCoreAudioDriver::MeasureCallback called");

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

  203.     

  204.     // Setup threadded based log function

  205.     set_threaded_log_function();

  206.     return noErr;

  207. }

  208. 

  209. OSStatus JackCoreAudioDriver::SRNotificationCallback(AudioDeviceID inDevice,

  210.         UInt32 inChannel,

  211.         Boolean	isInput,

  212.         AudioDevicePropertyID inPropertyID,

  213.         void* inClientData)

  214. {

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

  216. 

  217.     switch (inPropertyID) {

  218. 

  219.         case kAudioDevicePropertyNominalSampleRate: {

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

  221.             driver->fState = true;

  222.             break;

  223.         }

  224.     }

  225. 

  226.     return noErr;

  227. }

  228. 

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

  230. 

  231. OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,

  232.         UInt32 inChannel,

  233.         Boolean	isInput,

  234.         AudioDevicePropertyID inPropertyID,

  235.         void* inClientData)

  236. {

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

  238.          

  239.     switch (inPropertyID) {

  240. 

  241.         case kAudioDeviceProcessorOverload:

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

  243.             jack_time_t cur_time = GetMicroSeconds();

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

  245.             break;

  246. 

  247.         case kAudioDevicePropertyStreamConfiguration:

  248.         case kAudioDevicePropertyNominalSampleRate: {

  249. 

  250.             UInt32 outSize = sizeof(Float64);

  251.             Float64 sampleRate;

  252.             int in_nChannels = 0;

  253.             int out_nChannels = 0;

  254.             char capture_driver_name[256];

  255.             char playback_driver_name[256];

  256.             CFStringRef ref;

  257. 

  258.             // Stop and restart

  259.             driver->Stop();

  260.             driver->RemoveListeners();

  261.             driver->CloseAUHAL();

  262. 

  263.             OSStatus err = AudioDeviceGetProperty(driver->fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyNominalSampleRate, &outSize, &sampleRate);

  264.             if (err != noErr) {

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

  266.                 printError(err);

  267.             }

  268.             jack_log("JackCoreAudioDriver::DeviceNotificationCallback kAudioDevicePropertyNominalSampleRate %ld", long(sampleRate));

  269. 

  270.             if (driver->SetupDevices(driver->fCaptureUID, driver->fPlaybackUID, capture_driver_name, playback_driver_name) < 0)

  271.                 return -1;

  272. 

  273.             if (driver->SetupChannels(driver->fCapturing, driver->fPlaying, driver->fInChannels, driver->fOutChannels, in_nChannels, out_nChannels, false) < 0)

  274.                 return -1;

  275. 

  276.             if (driver->SetupBufferSizeAndSampleRate(driver->fEngineControl->fBufferSize, sampleRate)  < 0)

  277.                 return -1;

  278. 

  279.             if (driver->OpenAUHAL(driver->fCapturing,

  280.                                   driver->fPlaying,

  281.                                   driver->fInChannels,

  282.                                   driver->fOutChannels,

  283.                                   in_nChannels,

  284.                                   out_nChannels,

  285.                                   driver->fEngineControl->fBufferSize,

  286.                                   sampleRate,

  287.                                   false) < 0)

  288.                 goto error;

  289. 

  290.             if (driver->AddListeners() < 0)

  291.                 goto error;

  292. 

  293.             driver->Start();

  294. 

  295.             // Send notification to be used in JackPilot or JackRouter plugin

  296.             jack_error("Device restart...");

  297.             ref = CFStringCreateWithCString(NULL, driver->fEngineControl->fServerName, kCFStringEncodingMacRoman);

  298.             CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),

  299.                     CFSTR("com.grame.jackserver.restart"),

  300.                     ref,

  301.                     NULL,

  302.                     kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);

  303.             CFRelease(ref);

  304.             return noErr;

  305. error:

  306.             driver->CloseAUHAL();

  307.             break;

  308.         }

  309.     }

  310.     return noErr;

  311. }

  312. 

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

  314. {

  315.     UInt32 size = sizeof(AudioValueTranslation);

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

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

  318. 

  319.     if (inIUD == NULL) {

  320.         return kAudioHardwareUnspecifiedError;

  321.     } else {

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

  323.         CFRelease(inIUD);

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

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

  326.     }

  327. }

  328. 

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

  330. {

  331.     OSStatus res;

  332.     UInt32 theSize = sizeof(UInt32);

  333.     AudioDeviceID inDefault;

  334.     AudioDeviceID outDefault;

  335. 

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

  337.         return res;

  338. 

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

  340.         return res;

  341. 

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

  343. 

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

  345.     if (inDefault == outDefault) {

  346.         *id = inDefault;

  347.         return noErr;

  348.     } else {

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

  350.         return kAudioHardwareBadDeviceError;

  351.     }

  352. }

  353. 

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

  355. {

  356.     OSStatus res;

  357.     UInt32 theSize = sizeof(UInt32);

  358.     AudioDeviceID inDefault;

  359. 

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

  361.         return res;

  362. 

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

  364.     *id = inDefault;

  365.     return noErr;

  366. }

  367. 

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

  369. {

  370.     OSStatus res;

  371.     UInt32 theSize = sizeof(UInt32);

  372.     AudioDeviceID outDefault;

  373. 

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

  375.         return res;

  376. 

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

  378.     *id = outDefault;

  379.     return noErr;

  380. }

  381. 

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

  383. {

  384.     UInt32 size = 256;

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

  386. }

  387. 

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

  389. {

  390.     OSStatus err = noErr;

  391.     UInt32	outSize;

  392.     Boolean	outWritable;

  393.     AudioBufferList* bufferList = 0;

  394. 

  395.     channelCount = 0;

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

  397.     if (err == noErr) {

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

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

  400.         if (err == noErr) {

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

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

  403.         }

  404. 

  405.         if (bufferList)

  406.             free(bufferList);

  407.     }

  408. 

  409.     return err;

  410. }

  411. 

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

  413.         : JackAudioDriver(name, alias, engine, table), fJackInputData(NULL), fDriverOutputData(NULL), fState(false), fIOUsage(1.f)

  414. {}

  415. 

  416. JackCoreAudioDriver::~JackCoreAudioDriver()

  417. {}

  418. 

  419. int JackCoreAudioDriver::SetupDevices(const char* capture_driver_uid, const char* playback_driver_uid, char* capture_driver_name, char* playback_driver_name)

  420. {

  421.     capture_driver_name[0] = 0;

  422.     playback_driver_name[0] = 0;

  423. 

  424.     // Duplex

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

  426.         jack_log("JackCoreAudioDriver::Open duplex");

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

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

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

  430.                 return -1;

  431.             }

  432.         }

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

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

  435.             return -1;

  436.         }

  437. 

  438.         // Capture only

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

  440.         jack_log("JackCoreAudioDriver::Open capture only");

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

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

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

  444.                 return -1;

  445.             }

  446.         }

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

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

  449.             return -1;

  450.         }

  451. 

  452.         // Playback only

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

  454.         jack_log("JackCoreAudioDriver::Open playback only");

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

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

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

  458.                 return -1;

  459.             }

  460.         }

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

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

  463.             return -1;

  464.         }

  465. 

  466.         // Use default driver in duplex mode

  467.     } else {

  468.         jack_log("JackCoreAudioDriver::Open default driver");

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

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

  471.             return -1;

  472.         }

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

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

  475.             return -1;

  476.         }

  477.     }

  478. 

  479.     return 0;

  480. }

  481. 

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

  483. {

  484.     OSStatus err = noErr;

  485. 

  486.     if (capturing) {

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

  488.         if (err != noErr) {

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

  490.             printError(err);

  491.             return -1;

  492.         }

  493.     }

  494. 

  495.     if (playing) {

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

  497.         if (err != noErr) {

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

  499.             printError(err);

  500.             return -1;

  501.         }

  502.     }

  503. 

  504.     if (inchannels > in_nChannels) {

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

  506.         if (strict)

  507.             return -1;

  508.     }

  509. 

  510.     if (outchannels > out_nChannels) {

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

  512.         if (strict)

  513.             return -1;

  514.     }

  515. 

  516.     if (inchannels == 0) {

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

  518.         inchannels = in_nChannels;

  519.     }

  520. 

  521.     if (outchannels == 0) {

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

  523.         outchannels = out_nChannels;

  524.     }

  525. 

  526.     return 0;

  527. }

  528. 

  529. int JackCoreAudioDriver::SetupBufferSizeAndSampleRate(jack_nframes_t buffer_size, jack_nframes_t samplerate)

  530. {

  531.     OSStatus err = noErr;

  532.     UInt32 outSize;

  533.     Float64 sampleRate;

  534. 

  535.     // Setting buffer size

  536.     outSize = sizeof(UInt32);

  537.     err = AudioDeviceSetProperty(fDeviceID, NULL, 0, false, kAudioDevicePropertyBufferFrameSize, outSize, &buffer_size);

  538.     if (err != noErr) {

  539.         jack_error("Cannot set buffer size %ld", buffer_size);

  540.         printError(err);

  541.         return -1;

  542.     }

  543. 

  544.     // Get sample rate

  545.     outSize =  sizeof(Float64);

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

  547.     if (err != noErr) {

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

  549.         printError(err);

  550.         return -1;

  551.     }

  552. 

  553.     // If needed, set new sample rate

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

  555.         sampleRate = (Float64)samplerate;

  556. 

  557.         // To get SR change notification

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

  559.         if (err != noErr) {

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

  561.             printError(err);

  562.             return -1;

  563.         }

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

  565.         if (err != noErr) {

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

  567.             printError(err);

  568.             return -1;

  569.         }

  570. 

  571.         // Waiting for SR change notification

  572.         int count = 0;

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

  574.             usleep(100000);

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

  576.         }

  577. 

  578.         // Remove SR change notification

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

  580.     }

  581. 

  582.     return 0;

  583. }

  584. 

  585. int JackCoreAudioDriver::OpenAUHAL(bool capturing,

  586.                                    bool playing,

  587.                                    int inchannels,

  588.                                    int outchannels,

  589.                                    int in_nChannels,

  590.                                    int out_nChannels,

  591.                                    jack_nframes_t buffer_size,

  592.                                    jack_nframes_t samplerate,

  593.                                    bool strict)

  594. {

  595.     ComponentResult err1;

  596.     UInt32 enableIO;

  597.     AudioStreamBasicDescription srcFormat, dstFormat;

  598. 

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

  600. 

  601.     // AUHAL

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

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

  604. 

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

  606.     if (err1 != noErr) {

  607.         jack_error("Error calling OpenAComponent");

  608.         printError(err1);

  609.         return -1;

  610.     }

  611. 

  612.     err1 = AudioUnitInitialize(fAUHAL);

  613.     if (err1 != noErr) {

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

  615.         printError(err1);

  616.         return -1;

  617.     }

  618. 

  619.     // Start I/O

  620.     enableIO = 1;

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

  622.         jack_log("Setup AUHAL input");

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

  624.         if (err1 != noErr) {

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

  626.             printError(err1);

  627.             if (strict)

  628.                 return -1;

  629.         }

  630.     }

  631. 

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

  633.         jack_log("Setup AUHAL output");

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

  635.         if (err1 != noErr) {

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

  637.             printError(err1);

  638.             if (strict)

  639.                 return -1;

  640.         }

  641.     }

  642. 

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

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

  645.     if (err1 != noErr) {

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

  647.         printError(err1);

  648.         if (strict)

  649.             return -1;

  650.     }

  651. 

  652.     // Set buffer size

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

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

  655.         if (err1 != noErr) {

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

  657.             printError(err1);

  658.             if (strict)

  659.                 return -1;

  660.         }

  661.     }

  662. 

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

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

  665.         if (err1 != noErr) {

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

  667.             printError(err1);

  668.             if (strict)

  669.                 return -1;

  670.         }

  671.     }

  672. 

  673.     // Setup channel map

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

  675.         SInt32 chanArr[in_nChannels];

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

  677.             chanArr[i] = -1;

  678.         }

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

  680.             chanArr[i] = i;

  681.         }

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

  683.         if (err1 != noErr) {

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

  685.             printError(err1);

  686.         }

  687.     }

  688. 

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

  690.         SInt32 chanArr[out_nChannels];

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

  692.             chanArr[i] = -1;

  693.         }

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

  695.             chanArr[i] = i;

  696.         }

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

  698.         if (err1 != noErr) {

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

  700.             printError(err1);

  701.         }

  702.     }

  703. 

  704.     // Setup stream converters

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

  706.     srcFormat.mSampleRate = samplerate;

  707.     srcFormat.mFormatID = kAudioFormatLinearPCM;

  708.     srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  709.     srcFormat.mBytesPerPacket = sizeof(float);

  710.     srcFormat.mFramesPerPacket = 1;

  711.     srcFormat.mBytesPerFrame = sizeof(float);

  712.     srcFormat.mChannelsPerFrame = outchannels;

  713.     srcFormat.mBitsPerChannel = 32;

  714. 

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

  716.     if (err1 != noErr) {

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

  718.         printError(err1);

  719.     }

  720. 

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

  722.     dstFormat.mSampleRate = samplerate;

  723.     dstFormat.mFormatID = kAudioFormatLinearPCM;

  724.     dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;

  725.     dstFormat.mBytesPerPacket = sizeof(float);

  726.     dstFormat.mFramesPerPacket = 1;

  727.     dstFormat.mBytesPerFrame = sizeof(float);

  728.     dstFormat.mChannelsPerFrame = inchannels;

  729.     dstFormat.mBitsPerChannel = 32;

  730. 

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

  732.     if (err1 != noErr) {

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

  734.         printError(err1);

  735.     }

  736. 

  737.     // Setup callbacks

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

  739.         AURenderCallbackStruct output;

  740.         output.inputProc = Render;

  741.         output.inputProcRefCon = this;

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

  743.         if (err1 != noErr) {

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

  745.             printError(err1);

  746.             return -1;

  747.         }

  748.     } else {

  749.         AURenderCallbackStruct output;

  750.         output.inputProc = Render;

  751.         output.inputProcRefCon = this;

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

  753.         if (err1 != noErr) {

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

  755.             printError(err1);

  756.             return -1;

  757.         }

  758.     }

  759. 

  760.     return 0;

  761. }

  762. 

  763. int JackCoreAudioDriver::SetupBuffers(int inchannels)

  764. {

  765.     // Prepare buffers

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

  767.     if (fJackInputData == 0) {

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

  769.         return -1;

  770.     }

  771.     fJackInputData->mNumberBuffers = inchannels;

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

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

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

  775.     }

  776.     return 0;

  777. }

  778. 

  779. void JackCoreAudioDriver::DisposeBuffers()

  780. {

  781.     if (fJackInputData) {

  782.         free(fJackInputData);

  783.         fJackInputData = 0;

  784.     }

  785. }

  786. 

  787. void JackCoreAudioDriver::CloseAUHAL()

  788. {

  789.     AudioUnitUninitialize(fAUHAL);

  790.     CloseComponent(fAUHAL);

  791. }

  792. 

  793. int JackCoreAudioDriver::AddListeners()

  794. {

  795.     OSStatus err = noErr;

  796. 

  797.     // Add listeners

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

  799.     if (err != noErr) {

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

  801.         printError(err);

  802.         return -1;

  803.     }

  804. 

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

  806.     if (err != noErr) {

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

  808.         printError(err);

  809.         return -1;

  810.     }

  811. 

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

  813.     if (err != noErr) {

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

  815.         printError(err);

  816.         return -1;

  817.     }

  818. 

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

  820.     if (err != noErr) {

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

  822.         printError(err);

  823.         return -1;

  824.     }

  825. 

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

  827.     if (err != noErr) {

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

  829.         printError(err);

  830.         return -1;

  831.     }

  832. 

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

  834.     if (err != noErr) {

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

  836.         printError(err);

  837.         return -1;

  838.     }

  839. 

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

  841.         UInt32 outSize = sizeof(float);

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

  843.         if (err != noErr) {

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

  845.             printError(err);

  846.         }

  847.     }

  848. 

  849.     return 0;

  850. }

  851. 

  852. void JackCoreAudioDriver::RemoveListeners()

  853. {

  854. /*

  855. #ifdef MAC_OS_X_VERSION_10_5

  856.     AudioDeviceDestroyIOProcID(fDeviceID, fMesureCallbackID);

  857. #else

  858.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

  859. #endif

  860. */

  861.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

  862.      

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

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

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

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

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

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

  869. }

  870. 

  871. int JackCoreAudioDriver::Open(jack_nframes_t buffer_size,

  872.                               jack_nframes_t samplerate,

  873.                               bool capturing,

  874.                               bool playing,

  875.                               int inchannels,

  876.                               int outchannels,

  877.                               bool monitor,

  878.                               const char* capture_driver_uid,

  879.                               const char* playback_driver_uid,

  880.                               jack_nframes_t capture_latency,

  881.                               jack_nframes_t playback_latency,

  882.                               int async_output_latency)

  883. {

  884.     int in_nChannels = 0;

  885.     int out_nChannels = 0;

  886.     char capture_driver_name[256];

  887.     char playback_driver_name[256];

  888. 

  889.     // Keep initial state

  890.     fCapturing = capturing;

  891.     fPlaying = playing;

  892.     fInChannels = inchannels;

  893.     fOutChannels = outchannels;

  894.     fMonitor = monitor;

  895.     strcpy(fCaptureUID, capture_driver_uid);

  896.     strcpy(fPlaybackUID, playback_driver_uid);

  897.     fCaptureLatency = capture_latency;

  898.     fPlaybackLatency = playback_latency;

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

  900. 

  901.     if (SetupDevices(capture_driver_uid, playback_driver_uid, capture_driver_name, playback_driver_name) < 0)

  902.         return -1;

  903. 

  904.     // Generic JackAudioDriver Open

  905.     if (JackAudioDriver::Open(buffer_size, samplerate, capturing, playing, inchannels, outchannels, monitor, capture_driver_name, playback_driver_name, capture_latency, playback_latency) != 0)

  906.         return -1;

  907. 

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

  909.         return -1;

  910. 

  911.     if (SetupBufferSizeAndSampleRate(buffer_size, samplerate)  < 0)

  912.         return -1;

  913. 

  914.     if (OpenAUHAL(capturing, playing, inchannels, outchannels, in_nChannels, out_nChannels, buffer_size, samplerate, true) < 0)

  915.         goto error;

  916. 

  917.     if (capturing && inchannels > 0)

  918.         if (SetupBuffers(inchannels) < 0)

  919.             goto error;

  920. 

  921.     if (AddListeners() < 0)

  922.         goto error;

  923. 

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

  925.     fCaptureChannels = inchannels;

  926.     fPlaybackChannels = outchannels;

  927.     return noErr;

  928. 

  929. error:

  930.     Close();

  931.     return -1;

  932. }

  933. 

  934. int JackCoreAudioDriver::Close()

  935. {

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

  937.     Stop();

  938.     JackAudioDriver::Close();

  939.     RemoveListeners();

  940.     DisposeBuffers();

  941.     CloseAUHAL();

  942.     return 0;

  943. }

  944. 

  945. int JackCoreAudioDriver::Attach()

  946. {

  947.     OSStatus err;

  948.     JackPort* port;

  949.     jack_port_id_t port_index;

  950.     UInt32 size;

  951.     Boolean isWritable;

  952.     char channel_name[64];

  953.     char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  954.     char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  955.     unsigned long port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;

  956. 

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

  958. 

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

  960. 

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

  962.         if (err != noErr)

  963.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

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

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

  966.             if (err != noErr)

  967.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

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

  969.         } else {

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

  971.         }

  972. 

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

  974. 

  975.         if ((port_index = fGraphManager->AllocatePort(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, (JackPortFlags)port_flags, fEngineControl->fBufferSize)) == NO_PORT) {

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

  977.             return -1;

  978.         }

  979. 

  980.         size = sizeof(UInt32);

  981.         UInt32 value1 = 0;

  982.         UInt32 value2 = 0;

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

  984.         if (err != noErr)

  985.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

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

  987.         if (err != noErr)

  988.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  989. 

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

  991.         port->SetAlias(alias);

  992.         port->SetLatency(fEngineControl->fBufferSize + value1 + value2 + fCaptureLatency);

  993.         fCapturePortList[i] = port_index;

  994.     }

  995. 

  996.     port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;

  997. 

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

  999. 

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

  1001.         if (err != noErr)

  1002.             jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error ");

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

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

  1005.             if (err != noErr)

  1006.                 jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error ");

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

  1008.         } else {

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

  1010.         }

  1011. 

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

  1013. 

  1014.         if ((port_index = fGraphManager->AllocatePort(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, (JackPortFlags)port_flags, fEngineControl->fBufferSize)) == NO_PORT) {

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

  1016.             return -1;

  1017.         }

  1018. 

  1019.         size = sizeof(UInt32);

  1020.         UInt32 value1 = 0;

  1021.         UInt32 value2 = 0;

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

  1023.         if (err != noErr)

  1024.             jack_log("AudioDeviceGetProperty kAudioDevicePropertyLatency error ");

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

  1026.         if (err != noErr)

  1027.             jack_log("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error ");

  1028. 

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

  1030.         port->SetAlias(alias);

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

  1032.         port->SetLatency(fEngineControl->fBufferSize + ((fEngineControl->fSyncMode) ? 0 : fEngineControl->fBufferSize * fIOUsage) + value1 + value2 + fPlaybackLatency);

  1033.         fPlaybackPortList[i] = port_index;

  1034. 

  1035.         // Monitor ports

  1036.         if (fWithMonitorPorts) {

  1037.             jack_log("Create monitor port ");

  1038.             snprintf(name, sizeof(name) - 1, "%s:%s:monitor_%u", fAliasName, fPlaybackDriverName, i + 1);

  1039.             if ((port_index = fGraphManager->AllocatePort(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, fEngineControl->fBufferSize)) == NO_PORT) {

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

  1041.                 return -1;

  1042.             } else {

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

  1044.                 port->SetLatency(fEngineControl->fBufferSize);

  1045.                 fMonitorPortList[i] = port_index;

  1046.             }

  1047.         }

  1048.     }

  1049. 

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

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

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

  1053.     }

  1054. 

  1055.     return 0;

  1056. }

  1057. 

  1058. int JackCoreAudioDriver::Start()

  1059. {

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

  1061.     JackAudioDriver::Start();

  1062. /*

  1063. #ifdef MAC_OS_X_VERSION_10_5

  1064.     OSStatus err = AudioDeviceCreateIOProcID(fDeviceID, MeasureCallback, this, &fMesureCallbackID);

  1065. #else

  1066.     OSStatus err = AudioDeviceAddIOProc(fDeviceID, MeasureCallback, this);

  1067. #endif

  1068. */

  1069.     OSStatus err = AudioDeviceAddIOProc(fDeviceID, MeasureCallback, this);

  1070.     

  1071.     if (err != noErr)

  1072.         return -1;

  1073. 

  1074.     err = AudioOutputUnitStart(fAUHAL);

  1075.     if (err != noErr)

  1076.         return -1;

  1077. 

  1078.     if ((err = AudioDeviceStart(fDeviceID, MeasureCallback)) != noErr) {

  1079.         jack_error("Cannot start MeasureCallback");

  1080.         printError(err);

  1081.         return -1;

  1082.     }

  1083. 

  1084.     return 0;

  1085. }

  1086. 

  1087. int JackCoreAudioDriver::Stop()

  1088. {

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

  1090.     AudioDeviceStop(fDeviceID, MeasureCallback);

  1091. /*

  1092. #ifdef MAC_OS_X_VERSION_10_5

  1093.     AudioDeviceDestroyIOProcID(fDeviceID, fMesureCallbackID);

  1094. #else

  1095.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

  1096. #endif

  1097. */

  1098.     AudioDeviceRemoveIOProc(fDeviceID, MeasureCallback);

  1099. 

  1100.     return (AudioOutputUnitStop(fAUHAL) == noErr) ? 0 : -1;

  1101. }

  1102. 

  1103. int JackCoreAudioDriver::SetBufferSize(jack_nframes_t buffer_size)

  1104. {

  1105.     OSStatus err;

  1106.     UInt32 outSize = sizeof(UInt32);

  1107. 

  1108.     err = AudioDeviceSetProperty(fDeviceID, NULL, 0, false, kAudioDevicePropertyBufferFrameSize, outSize, &buffer_size);

  1109.     if (err != noErr) {

  1110.         jack_error("Cannot set buffer size %ld", buffer_size);

  1111.         printError(err);

  1112.         return -1;

  1113.     }

  1114. 

  1115.     JackAudioDriver::SetBufferSize(buffer_size); // never fails

  1116. 

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

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

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

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

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

  1122.     }

  1123. 

  1124.     return 0;

  1125. }

  1126. 

  1127. } // end of namespace

  1128. 

  1129. 

  1130. #ifdef __cplusplus

  1131. extern "C"

  1132. {

  1133. #endif

  1134. 

  1135.     SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor() 

  1136.     {

  1137.         jack_driver_desc_t *desc;

  1138.         unsigned int i;

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

  1140. 

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

  1142.         strcpy(desc->desc, "Apple CoreAudio API based audio backend");      // size MUST be less then JACK_DRIVER_PARAM_DESC + 1

  1143.         

  1144.         desc->nparams = 14;

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

  1146. 

  1147.         i = 0;

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

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

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

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

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

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

  1154. 

  1155.         i++;

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

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

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

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

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

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

  1162. 

  1163.         i++;

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

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

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

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

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

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

  1170. 

  1171.         i++;

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

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

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

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

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

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

  1178. 

  1179.         i++;

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

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

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

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

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

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

  1186. 

  1187.         i++;

  1188.         strcpy (desc->params[i].name, "monitor");

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

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

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

  1192.         strcpy(desc->params[i].short_desc, "Provide monitor ports for the output");

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

  1194. 

  1195.         i++;

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

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

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

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

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

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

  1202. 

  1203.         i++;

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

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

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

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

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

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

  1210. 

  1211.         i++;

  1212.         strcpy(desc->params[i].name, "period");

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

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

  1215.         desc->params[i].value.ui = 128U;

  1216.         strcpy(desc->params[i].short_desc, "Frames per period");

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

  1218. 

  1219.         i++;

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

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

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

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

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

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

  1226. 

  1227.         i++;

  1228.         strcpy(desc->params[i].name, "input-latency");

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

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

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

  1232.         strcpy(desc->params[i].short_desc, "Extra input latency (frames)");

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

  1234. 

  1235.         i++;

  1236.         strcpy(desc->params[i].name, "output-latency");

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

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

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

  1240.         strcpy(desc->params[i].short_desc, "Extra output latency (frames)");

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

  1242. 

  1243.         i++;

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

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

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

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

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

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

  1250.         

  1251.         i++;

  1252.         strcpy(desc->params[i].name, "async-latency");

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

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

  1255.         desc->params[i].value.i = 100;

  1256.         strcpy(desc->params[i].short_desc, "Extra output latency in aynchronous mode (percent)");

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

  1258. 

  1259.         return desc;

  1260.     }

  1261. 

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

  1263.     {

  1264.         jack_nframes_t srate = 44100;

  1265.         jack_nframes_t frames_per_interrupt = 128;

  1266.         int capture = FALSE;

  1267.         int playback = FALSE;

  1268.         int chan_in = 0;

  1269.         int chan_out = 0;

  1270.         bool monitor = false;

  1271.         const char* capture_driver_uid = "";

  1272.         const char* playback_driver_uid = "";

  1273.         const JSList *node;

  1274.         const jack_driver_param_t *param;

  1275.         jack_nframes_t systemic_input_latency = 0;

  1276.         jack_nframes_t systemic_output_latency = 0;

  1277.         int async_output_latency = 100;

  1278.     

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

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

  1281.        

  1282.             switch (param->character) {

  1283. 

  1284.                 case 'd':

  1285.                     capture_driver_uid = strdup(param->value.str);

  1286.                     playback_driver_uid = strdup(param->value.str);

  1287.                     break;

  1288. 

  1289.                 case 'D':

  1290.                     capture = TRUE;

  1291.                     playback = TRUE;

  1292.                     break;

  1293. 

  1294.                 case 'c':

  1295.                     chan_in = chan_out = (int) param->value.ui;

  1296.                     break;

  1297. 

  1298.                 case 'i':

  1299.                     chan_in = (int) param->value.ui;

  1300.                     break;

  1301. 

  1302.                 case 'o':

  1303.                     chan_out = (int) param->value.ui;

  1304.                     break;

  1305. 

  1306.                 case 'C':

  1307.                     capture = TRUE;

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

  1309.                         capture_driver_uid = strdup(param->value.str);

  1310.                     }

  1311.                     break;

  1312. 

  1313.                 case 'P':

  1314.                     playback = TRUE;

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

  1316.                         playback_driver_uid = strdup(param->value.str);

  1317.                     }

  1318.                     break;

  1319. 

  1320.                 case 'm':

  1321.                     monitor = param->value.i;

  1322.                     break;

  1323. 

  1324.                 case 'r':

  1325.                     srate = param->value.ui;

  1326.                     break;

  1327. 

  1328.                 case 'p':

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

  1330.                     break;

  1331. 

  1332.                 case 'I':

  1333.                     systemic_input_latency = param->value.ui;

  1334.                     break;

  1335. 

  1336.                 case 'O':

  1337.                     systemic_output_latency = param->value.ui;

  1338.                     break;

  1339. 

  1340.                 case 'l':

  1341.                     Jack::DisplayDeviceNames();

  1342.                     break;

  1343.                     

  1344.                 case 'L':

  1345.                     async_output_latency = param->value.ui;

  1346.                     break;

  1347.             }

  1348.         }

  1349. 

  1350.         /* duplex is the default */

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

  1352.             capture = TRUE;

  1353.             playback = TRUE;

  1354.         }

  1355. 

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

  1357.         if (driver->Open(frames_per_interrupt, srate, capture, playback, chan_in, chan_out, monitor, capture_driver_uid, 

  1358.             playback_driver_uid, systemic_input_latency, systemic_output_latency, async_output_latency) == 0) {

  1359.             return driver;

  1360.         } else {

  1361.             delete driver;

  1362.             return NULL;

  1363.         }

  1364.     }

  1365. 

  1366. #ifdef __cplusplus

  1367. }

  1368. #endif

  1369.