/* * Copyright © 2011 Mozilla Foundation * * This program is made available under an ISC-style license. See the * accompanying file LICENSE for details. */ #undef NDEBUG #include <TargetConditionals.h> #include <assert.h> #include <mach/mach_time.h> #include <pthread.h> #include <stdlib.h> #include <AudioUnit/AudioUnit.h> #if !TARGET_OS_IPHONE #include <AvailabilityMacros.h> #include <CoreAudio/AudioHardware.h> #include <CoreAudio/HostTime.h> #include <CoreFoundation/CoreFoundation.h> #endif #include <CoreAudio/CoreAudioTypes.h> #include <AudioToolbox/AudioToolbox.h> #include "cubeb/cubeb.h" #include "cubeb-internal.h" #include "cubeb_panner.h" #if !TARGET_OS_IPHONE #include "cubeb_osx_run_loop.h" #endif #include "cubeb_resampler.h" #include "cubeb_ring_array.h" #include "cubeb_utils.h" #include <algorithm> #include <atomic> #if !defined(kCFCoreFoundationVersionNumber10_7) /* From CoreFoundation CFBase.h */ #define kCFCoreFoundationVersionNumber10_7 635.00 #endif #if !TARGET_OS_IPHONE && MAC_OS_X_VERSION_MIN_REQUIRED < 1060 #define AudioComponent Component #define AudioComponentDescription ComponentDescription #define AudioComponentFindNext FindNextComponent #define AudioComponentInstanceNew OpenAComponent #define AudioComponentInstanceDispose CloseComponent #endif #if MAC_OS_X_VERSION_MIN_REQUIRED < 101000 typedef UInt32 AudioFormatFlags; #endif #define CUBEB_STREAM_MAX 8 #define AU_OUT_BUS 0 #define AU_IN_BUS 1 #define PRINT_ERROR_CODE(str, r) do { \ LOG("System call failed: %s (rv: %d)", str, r); \ } while(0) const char * DISPATCH_QUEUE_LABEL = "org.mozilla.cubeb"; /* Testing empirically, some headsets report a minimal latency that is very * low, but this does not work in practice. Lie and say the minimum is 256 * frames. */ const uint32_t SAFE_MIN_LATENCY_FRAMES = 256; const uint32_t SAFE_MAX_LATENCY_FRAMES = 512; void audiounit_stream_stop_internal(cubeb_stream * stm); void audiounit_stream_start_internal(cubeb_stream * stm); static void audiounit_close_stream(cubeb_stream *stm); static int audiounit_setup_stream(cubeb_stream *stm); extern cubeb_ops const audiounit_ops; struct cubeb { cubeb_ops const * ops; owned_critical_section mutex; std::atomic<int> active_streams; uint32_t global_latency_frames = 0; int limit_streams; cubeb_device_collection_changed_callback collection_changed_callback; void * collection_changed_user_ptr; /* Differentiate input from output devices. */ cubeb_device_type collection_changed_devtype; uint32_t devtype_device_count; AudioObjectID * devtype_device_array; // The queue is asynchronously deallocated once all references to it are released dispatch_queue_t serial_queue = dispatch_queue_create(DISPATCH_QUEUE_LABEL, DISPATCH_QUEUE_SERIAL); }; class auto_array_wrapper { public: explicit auto_array_wrapper(auto_array<float> * ar) : float_ar(ar) , short_ar(nullptr) {assert((float_ar && !short_ar) || (!float_ar && short_ar));} explicit auto_array_wrapper(auto_array<short> * ar) : float_ar(nullptr) , short_ar(ar) {assert((float_ar && !short_ar) || (!float_ar && short_ar));} ~auto_array_wrapper() { auto_lock l(lock); assert((float_ar && !short_ar) || (!float_ar && short_ar)); delete float_ar; delete short_ar; } void push(void * elements, size_t length){ assert((float_ar && !short_ar) || (!float_ar && short_ar)); auto_lock l(lock); if (float_ar) return float_ar->push(static_cast<float*>(elements), length); return short_ar->push(static_cast<short*>(elements), length); } size_t length() { assert((float_ar && !short_ar) || (!float_ar && short_ar)); auto_lock l(lock); if (float_ar) return float_ar->length(); return short_ar->length(); } void push_silence(size_t length) { assert((float_ar && !short_ar) || (!float_ar && short_ar)); auto_lock l(lock); if (float_ar) return float_ar->push_silence(length); return short_ar->push_silence(length); } bool pop(void * elements, size_t length) { assert((float_ar && !short_ar) || (!float_ar && short_ar)); auto_lock l(lock); if (float_ar) return float_ar->pop(static_cast<float*>(elements), length); return short_ar->pop(static_cast<short*>(elements), length); } void * data() { assert((float_ar && !short_ar) || (!float_ar && short_ar)); auto_lock l(lock); if (float_ar) return float_ar->data(); return short_ar->data(); } void clear() { assert((float_ar && !short_ar) || (!float_ar && short_ar)); auto_lock l(lock); if (float_ar) { float_ar->clear(); } else { short_ar->clear(); } } private: auto_array<float> * float_ar; auto_array<short> * short_ar; owned_critical_section lock; }; struct cubeb_stream { cubeb * context; cubeb_data_callback data_callback; cubeb_state_callback state_callback; cubeb_device_changed_callback device_changed_callback; /* Stream creation parameters */ cubeb_stream_params input_stream_params; cubeb_stream_params output_stream_params; cubeb_devid input_device; bool is_default_input; cubeb_devid output_device; /* User pointer of data_callback */ void * user_ptr; /* Format descriptions */ AudioStreamBasicDescription input_desc; AudioStreamBasicDescription output_desc; /* I/O AudioUnits */ AudioUnit input_unit; AudioUnit output_unit; /* I/O device sample rate */ Float64 input_hw_rate; Float64 output_hw_rate; /* Expected I/O thread interleave, * calculated from I/O hw rate. */ int expected_output_callbacks_in_a_row; owned_critical_section mutex; /* Hold the input samples in every * input callback iteration */ auto_array_wrapper * input_linear_buffer; /* Frames on input buffer */ std::atomic<uint32_t> input_buffer_frames; /* Frame counters */ uint64_t frames_played; uint64_t frames_queued; std::atomic<int64_t> frames_read; std::atomic<bool> shutdown; std::atomic<bool> draining; /* Latency requested by the user. */ uint32_t latency_frames; std::atomic<uint64_t> current_latency_frames; uint64_t hw_latency_frames; std::atomic<float> panning; cubeb_resampler * resampler; /* This is the number of output callback we got in a row. This is usually one, * but can be two when the input and output rate are different, and more when * a device has been plugged or unplugged, as there can be some time before * the device is ready. */ std::atomic<int> output_callback_in_a_row; /* This is true if a device change callback is currently running. */ std::atomic<bool> switching_device; std::atomic<bool> buffer_size_change_state{ false }; }; bool has_input(cubeb_stream * stm) { return stm->input_stream_params.rate != 0; } bool has_output(cubeb_stream * stm) { return stm->output_stream_params.rate != 0; } #if TARGET_OS_IPHONE typedef UInt32 AudioDeviceID; typedef UInt32 AudioObjectID; #define AudioGetCurrentHostTime mach_absolute_time uint64_t AudioConvertHostTimeToNanos(uint64_t host_time) { static struct mach_timebase_info timebase_info; static bool initialized = false; if (!initialized) { mach_timebase_info(&timebase_info); initialized = true; } long double answer = host_time; if (timebase_info.numer != timebase_info.denom) { answer *= timebase_info.numer; answer /= timebase_info.denom; } return (uint64_t)answer; } #endif static int64_t audiotimestamp_to_latency(AudioTimeStamp const * tstamp, cubeb_stream * stream) { if (!(tstamp->mFlags & kAudioTimeStampHostTimeValid)) { return 0; } uint64_t pres = AudioConvertHostTimeToNanos(tstamp->mHostTime); uint64_t now = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime()); return ((pres - now) * stream->output_desc.mSampleRate) / 1000000000LL; } static void audiounit_set_global_latency(cubeb_stream * stm, uint32_t latency_frames) { stm->mutex.assert_current_thread_owns(); assert(stm->context->active_streams == 1); stm->context->global_latency_frames = latency_frames; } static void audiounit_make_silent(AudioBuffer * ioData) { assert(ioData); assert(ioData->mData); memset(ioData->mData, 0, ioData->mDataByteSize); } static OSStatus audiounit_render_input(cubeb_stream * stm, AudioUnitRenderActionFlags * flags, AudioTimeStamp const * tstamp, UInt32 bus, UInt32 input_frames) { /* Create the AudioBufferList to store input. */ AudioBufferList input_buffer_list; input_buffer_list.mBuffers[0].mDataByteSize = stm->input_desc.mBytesPerFrame * input_frames; input_buffer_list.mBuffers[0].mData = nullptr; input_buffer_list.mBuffers[0].mNumberChannels = stm->input_desc.mChannelsPerFrame; input_buffer_list.mNumberBuffers = 1; /* Render input samples */ OSStatus r = AudioUnitRender(stm->input_unit, flags, tstamp, bus, input_frames, &input_buffer_list); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitRender", r); return r; } /* Copy input data in linear buffer. */ stm->input_linear_buffer->push(input_buffer_list.mBuffers[0].mData, input_frames * stm->input_desc.mChannelsPerFrame); LOGV("(%p) input: buffers %d, size %d, channels %d, frames %d.", stm, input_buffer_list.mNumberBuffers, input_buffer_list.mBuffers[0].mDataByteSize, input_buffer_list.mBuffers[0].mNumberChannels, input_frames); /* Advance input frame counter. */ assert(input_frames > 0); stm->frames_read += input_frames; return noErr; } static OSStatus audiounit_input_callback(void * user_ptr, AudioUnitRenderActionFlags * flags, AudioTimeStamp const * tstamp, UInt32 bus, UInt32 input_frames, AudioBufferList * /* bufs */) { cubeb_stream * stm = static_cast<cubeb_stream *>(user_ptr); long outframes; assert(stm->input_unit != NULL); assert(AU_IN_BUS == bus); if (stm->shutdown) { LOG("(%p) input shutdown", stm); return noErr; } // This happens when we're finally getting a new input callback after having // switched device, we can clear the input buffer now, only keeping the data // we just got. if (stm->output_callback_in_a_row > stm->expected_output_callbacks_in_a_row) { stm->input_linear_buffer->pop( nullptr, stm->input_linear_buffer->length() - input_frames * stm->input_stream_params.channels); } OSStatus r = audiounit_render_input(stm, flags, tstamp, bus, input_frames); if (r != noErr) { return r; } // Full Duplex. We'll call data_callback in the AudioUnit output callback. if (stm->output_unit != NULL) { stm->output_callback_in_a_row = 0; return noErr; } /* Input only. Call the user callback through resampler. Resampler will deliver input buffer in the correct rate. */ assert(input_frames <= stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame); long total_input_frames = stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame; outframes = cubeb_resampler_fill(stm->resampler, stm->input_linear_buffer->data(), &total_input_frames, NULL, 0); // Reset input buffer stm->input_linear_buffer->clear(); if (outframes < 0 || outframes != input_frames) { stm->shutdown = true; return noErr; } return noErr; } static bool is_extra_input_needed(cubeb_stream * stm) { /* If the output callback came first and this is a duplex stream, we need to * fill in some additional silence in the resampler. * Otherwise, if we had more than expected callbacks in a row, or we're currently * switching, we add some silence as well to compensate for the fact that * we're lacking some input data. */ /* If resampling is taking place after every output callback * the input buffer expected to be empty. Any frame left over * from resampling is stored inside the resampler available to * be used in next iteration as needed. * BUT when noop_resampler is operating we have left over * frames since it does not store anything internally. */ return stm->frames_read == 0 || (stm->input_linear_buffer->length() == 0 && (stm->output_callback_in_a_row > stm->expected_output_callbacks_in_a_row || stm->switching_device)); } static OSStatus audiounit_output_callback(void * user_ptr, AudioUnitRenderActionFlags * /* flags */, AudioTimeStamp const * tstamp, UInt32 bus, UInt32 output_frames, AudioBufferList * outBufferList) { assert(AU_OUT_BUS == bus); assert(outBufferList->mNumberBuffers == 1); cubeb_stream * stm = static_cast<cubeb_stream *>(user_ptr); stm->output_callback_in_a_row++; LOGV("(%p) output: buffers %d, size %d, channels %d, frames %d.", stm, outBufferList->mNumberBuffers, outBufferList->mBuffers[0].mDataByteSize, outBufferList->mBuffers[0].mNumberChannels, output_frames); long outframes = 0, input_frames = 0; void * output_buffer = NULL, * input_buffer = NULL; if (stm->shutdown) { LOG("(%p) output shutdown.", stm); audiounit_make_silent(&outBufferList->mBuffers[0]); return noErr; } stm->current_latency_frames = audiotimestamp_to_latency(tstamp, stm); if (stm->draining) { OSStatus r = AudioOutputUnitStop(stm->output_unit); assert(r == 0); if (stm->input_unit) { r = AudioOutputUnitStop(stm->input_unit); assert(r == 0); } stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_DRAINED); audiounit_make_silent(&outBufferList->mBuffers[0]); return noErr; } /* Get output buffer. */ output_buffer = outBufferList->mBuffers[0].mData; /* If Full duplex get also input buffer */ if (stm->input_unit != NULL) { if (is_extra_input_needed(stm)) { uint32_t min_input_frames_required = ceilf(stm->input_hw_rate / stm->output_hw_rate * stm->input_buffer_frames); stm->input_linear_buffer->push_silence(min_input_frames_required * stm->input_desc.mChannelsPerFrame); LOG("(%p) %s pushed %u frames of input silence.", stm, stm->frames_read == 0 ? "Input hasn't started," : stm->switching_device ? "Device switching," : "Drop out,", min_input_frames_required); } // The input buffer input_buffer = stm->input_linear_buffer->data(); // Number of input frames in the buffer input_frames = stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame; } /* Call user callback through resampler. */ outframes = cubeb_resampler_fill(stm->resampler, input_buffer, input_buffer ? &input_frames : NULL, output_buffer, output_frames); if (input_buffer) { stm->input_linear_buffer->pop(nullptr, input_frames * stm->input_desc.mChannelsPerFrame); } if (outframes < 0) { stm->shutdown = true; return noErr; } size_t outbpf = stm->output_desc.mBytesPerFrame; stm->draining = outframes < output_frames; stm->frames_played = stm->frames_queued; stm->frames_queued += outframes; AudioFormatFlags outaff = stm->output_desc.mFormatFlags; float panning = (stm->output_desc.mChannelsPerFrame == 2) ? stm->panning.load(std::memory_order_relaxed) : 0.0f; /* Post process output samples. */ if (stm->draining) { /* Clear missing frames (silence) */ memset((uint8_t*)output_buffer + outframes * outbpf, 0, (output_frames - outframes) * outbpf); } /* Pan stereo. */ if (panning != 0.0f) { if (outaff & kAudioFormatFlagIsFloat) { cubeb_pan_stereo_buffer_float((float*)output_buffer, outframes, panning); } else if (outaff & kAudioFormatFlagIsSignedInteger) { cubeb_pan_stereo_buffer_int((short*)output_buffer, outframes, panning); } } return noErr; } extern "C" { int audiounit_init(cubeb ** context, char const * /* context_name */) { cubeb * ctx; *context = NULL; ctx = (cubeb *)calloc(1, sizeof(cubeb)); assert(ctx); // Placement new to call the ctors of cubeb members. new (ctx) cubeb(); ctx->ops = &audiounit_ops; ctx->active_streams = 0; ctx->limit_streams = kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber10_7; #if !TARGET_OS_IPHONE cubeb_set_coreaudio_notification_runloop(); #endif *context = ctx; return CUBEB_OK; } } static char const * audiounit_get_backend_id(cubeb * /* ctx */) { return "audiounit"; } #if !TARGET_OS_IPHONE static int audiounit_get_output_device_id(AudioDeviceID * device_id) { UInt32 size; OSStatus r; AudioObjectPropertyAddress output_device_address = { kAudioHardwarePropertyDefaultOutputDevice, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster }; size = sizeof(*device_id); r = AudioObjectGetPropertyData(kAudioObjectSystemObject, &output_device_address, 0, NULL, &size, device_id); if (r != noErr) { PRINT_ERROR_CODE("output_device_id", r); return CUBEB_ERROR; } return CUBEB_OK; } static int audiounit_get_input_device_id(AudioDeviceID * device_id) { UInt32 size; OSStatus r; AudioObjectPropertyAddress input_device_address = { kAudioHardwarePropertyDefaultInputDevice, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster }; size = sizeof(*device_id); r = AudioObjectGetPropertyData(kAudioObjectSystemObject, &input_device_address, 0, NULL, &size, device_id); if (r != noErr) { return CUBEB_ERROR; } return CUBEB_OK; } static int audiounit_stream_get_volume(cubeb_stream * stm, float * volume); static int audiounit_stream_set_volume(cubeb_stream * stm, float volume); static int audiounit_uninstall_device_changed_callback(cubeb_stream * stm); static int audiounit_reinit_stream(cubeb_stream * stm) { auto_lock context_lock(stm->context->mutex); if (!stm->shutdown) { audiounit_stream_stop_internal(stm); } int r = audiounit_uninstall_device_changed_callback(stm); if (r != CUBEB_OK) { LOG("(%p) Could not uninstall the device changed callback", stm); } { auto_lock lock(stm->mutex); float volume = 0.0; int vol_rv = audiounit_stream_get_volume(stm, &volume); audiounit_close_stream(stm); if (audiounit_setup_stream(stm) != CUBEB_OK) { LOG("(%p) Stream reinit failed.", stm); return CUBEB_ERROR; } if (vol_rv == CUBEB_OK) { audiounit_stream_set_volume(stm, volume); } // Reset input frames to force new stream pre-buffer // silence if needed, check `is_extra_input_needed()` stm->frames_read = 0; // If the stream was running, start it again. if (!stm->shutdown) { audiounit_stream_start_internal(stm); } } return CUBEB_OK; } static OSStatus audiounit_property_listener_callback(AudioObjectID /* id */, UInt32 address_count, const AudioObjectPropertyAddress * addresses, void * user) { cubeb_stream * stm = (cubeb_stream*) user; stm->switching_device = true; LOG("(%p) Audio device changed, %d events.", stm, address_count); for (UInt32 i = 0; i < address_count; i++) { switch(addresses[i].mSelector) { case kAudioHardwarePropertyDefaultOutputDevice: { LOG("Event[%d] - mSelector == kAudioHardwarePropertyDefaultOutputDevice", i); // Allow restart to choose the new default stm->output_device = nullptr; } break; case kAudioHardwarePropertyDefaultInputDevice: { LOG("Event[%d] - mSelector == kAudioHardwarePropertyDefaultInputDevice", i); // Allow restart to choose the new default stm->input_device = nullptr; } break; case kAudioDevicePropertyDeviceIsAlive: { LOG("Event[%d] - mSelector == kAudioDevicePropertyDeviceIsAlive", i); // If this is the default input device ignore the event, // kAudioHardwarePropertyDefaultInputDevice will take care of the switch if (stm->is_default_input) { LOG("It's the default input device, ignore the event"); return noErr; } // Allow restart to choose the new default. Event register only for input. stm->input_device = nullptr; } break; case kAudioDevicePropertyDataSource: { LOG("Event[%d] - mSelector == kAudioHardwarePropertyDataSource", i); return noErr; } } } for (UInt32 i = 0; i < address_count; i++) { switch(addresses[i].mSelector) { case kAudioHardwarePropertyDefaultOutputDevice: case kAudioHardwarePropertyDefaultInputDevice: case kAudioDevicePropertyDeviceIsAlive: /* fall through */ case kAudioDevicePropertyDataSource: { auto_lock lock(stm->mutex); if (stm->device_changed_callback) { stm->device_changed_callback(stm->user_ptr); } break; } } } // Use a new thread, through the queue, to avoid deadlock when calling // Get/SetProperties method from inside notify callback dispatch_async(stm->context->serial_queue, ^() { if (audiounit_reinit_stream(stm) != CUBEB_OK) { stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_STOPPED); LOG("(%p) Could not reopen the stream after switching.", stm); } stm->switching_device = false; }); return noErr; } OSStatus audiounit_add_listener(cubeb_stream * stm, AudioDeviceID id, AudioObjectPropertySelector selector, AudioObjectPropertyScope scope, AudioObjectPropertyListenerProc listener) { AudioObjectPropertyAddress address = { selector, scope, kAudioObjectPropertyElementMaster }; return AudioObjectAddPropertyListener(id, &address, listener, stm); } OSStatus audiounit_remove_listener(cubeb_stream * stm, AudioDeviceID id, AudioObjectPropertySelector selector, AudioObjectPropertyScope scope, AudioObjectPropertyListenerProc listener) { AudioObjectPropertyAddress address = { selector, scope, kAudioObjectPropertyElementMaster }; return AudioObjectRemovePropertyListener(id, &address, listener, stm); } static AudioObjectID audiounit_get_default_device_id(cubeb_device_type type); static int audiounit_install_device_changed_callback(cubeb_stream * stm) { OSStatus r; if (stm->output_unit) { /* This event will notify us when the data source on the same device changes, * for example when the user plugs in a normal (non-usb) headset in the * headphone jack. */ AudioDeviceID output_dev_id; r = audiounit_get_output_device_id(&output_dev_id); if (r != noErr) { return CUBEB_ERROR; } r = audiounit_add_listener(stm, output_dev_id, kAudioDevicePropertyDataSource, kAudioDevicePropertyScopeOutput, &audiounit_property_listener_callback); if (r != noErr) { PRINT_ERROR_CODE("AudioObjectAddPropertyListener/output/kAudioDevicePropertyDataSource", r); return CUBEB_ERROR; } } if (stm->input_unit) { /* This event will notify us when the data source on the input device changes. */ AudioDeviceID input_dev_id; r = audiounit_get_input_device_id(&input_dev_id); if (r != noErr) { return CUBEB_ERROR; } r = audiounit_add_listener(stm, input_dev_id, kAudioDevicePropertyDataSource, kAudioDevicePropertyScopeInput, &audiounit_property_listener_callback); if (r != noErr) { PRINT_ERROR_CODE("AudioObjectAddPropertyListener/input/kAudioDevicePropertyDataSource", r); return CUBEB_ERROR; } /* Event to notify when the input is going away. */ AudioDeviceID dev = stm->input_device ? reinterpret_cast<intptr_t>(stm->input_device) : audiounit_get_default_device_id(CUBEB_DEVICE_TYPE_INPUT); r = audiounit_add_listener(stm, dev, kAudioDevicePropertyDeviceIsAlive, kAudioObjectPropertyScopeGlobal, &audiounit_property_listener_callback); if (r != noErr) { PRINT_ERROR_CODE("AudioObjectAddPropertyListener/input/kAudioDevicePropertyDeviceIsAlive", r); return CUBEB_ERROR; } } return CUBEB_OK; } static int audiounit_install_system_changed_callback(cubeb_stream * stm) { OSStatus r; if (stm->output_unit) { /* This event will notify us when the default audio device changes, * for example when the user plugs in a USB headset and the system chooses it * automatically as the default, or when another device is chosen in the * dropdown list. */ r = audiounit_add_listener(stm, kAudioObjectSystemObject, kAudioHardwarePropertyDefaultOutputDevice, kAudioObjectPropertyScopeGlobal, &audiounit_property_listener_callback); if (r != noErr) { LOG("AudioObjectAddPropertyListener/output/kAudioHardwarePropertyDefaultOutputDevice rv=%d", r); return CUBEB_ERROR; } } if (stm->input_unit) { /* This event will notify us when the default input device changes. */ r = audiounit_add_listener(stm, kAudioObjectSystemObject, kAudioHardwarePropertyDefaultInputDevice, kAudioObjectPropertyScopeGlobal, &audiounit_property_listener_callback); if (r != noErr) { LOG("AudioObjectAddPropertyListener/input/kAudioHardwarePropertyDefaultInputDevice rv=%d", r); return CUBEB_ERROR; } } return CUBEB_OK; } static int audiounit_uninstall_device_changed_callback(cubeb_stream * stm) { OSStatus r; if (stm->output_unit) { AudioDeviceID output_dev_id; r = audiounit_get_output_device_id(&output_dev_id); if (r != noErr) { return CUBEB_ERROR; } r = audiounit_remove_listener(stm, output_dev_id, kAudioDevicePropertyDataSource, kAudioDevicePropertyScopeOutput, &audiounit_property_listener_callback); if (r != noErr) { return CUBEB_ERROR; } } if (stm->input_unit) { AudioDeviceID input_dev_id; r = audiounit_get_input_device_id(&input_dev_id); if (r != noErr) { return CUBEB_ERROR; } r = audiounit_remove_listener(stm, input_dev_id, kAudioDevicePropertyDataSource, kAudioDevicePropertyScopeInput, &audiounit_property_listener_callback); if (r != noErr) { return CUBEB_ERROR; } } return CUBEB_OK; } static int audiounit_uninstall_system_changed_callback(cubeb_stream * stm) { OSStatus r; if (stm->output_unit) { r = audiounit_remove_listener(stm, kAudioObjectSystemObject, kAudioHardwarePropertyDefaultOutputDevice, kAudioObjectPropertyScopeGlobal, &audiounit_property_listener_callback); if (r != noErr) { return CUBEB_ERROR; } } if (stm->input_unit) { r = audiounit_remove_listener(stm, kAudioObjectSystemObject, kAudioHardwarePropertyDefaultInputDevice, kAudioObjectPropertyScopeGlobal, &audiounit_property_listener_callback); if (r != noErr) { return CUBEB_ERROR; } } return CUBEB_OK; } /* Get the acceptable buffer size (in frames) that this device can work with. */ static int audiounit_get_acceptable_latency_range(AudioValueRange * latency_range) { UInt32 size; OSStatus r; AudioDeviceID output_device_id; AudioObjectPropertyAddress output_device_buffer_size_range = { kAudioDevicePropertyBufferFrameSizeRange, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster }; if (audiounit_get_output_device_id(&output_device_id) != CUBEB_OK) { LOG("Could not get default output device id."); return CUBEB_ERROR; } /* Get the buffer size range this device supports */ size = sizeof(*latency_range); r = AudioObjectGetPropertyData(output_device_id, &output_device_buffer_size_range, 0, NULL, &size, latency_range); if (r != noErr) { PRINT_ERROR_CODE("AudioObjectGetPropertyData/buffer size range", r); return CUBEB_ERROR; } return CUBEB_OK; } #endif /* !TARGET_OS_IPHONE */ static AudioObjectID audiounit_get_default_device_id(cubeb_device_type type) { AudioObjectPropertyAddress adr = { 0, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster }; AudioDeviceID devid; UInt32 size; if (type == CUBEB_DEVICE_TYPE_OUTPUT) { adr.mSelector = kAudioHardwarePropertyDefaultOutputDevice; } else if (type == CUBEB_DEVICE_TYPE_INPUT) { adr.mSelector = kAudioHardwarePropertyDefaultInputDevice; } else { return kAudioObjectUnknown; } size = sizeof(AudioDeviceID); if (AudioObjectGetPropertyData(kAudioObjectSystemObject, &adr, 0, NULL, &size, &devid) != noErr) { return kAudioObjectUnknown; } return devid; } int audiounit_get_max_channel_count(cubeb * ctx, uint32_t * max_channels) { #if TARGET_OS_IPHONE //TODO: [[AVAudioSession sharedInstance] maximumOutputNumberOfChannels] *max_channels = 2; #else UInt32 size; OSStatus r; AudioDeviceID output_device_id; AudioStreamBasicDescription stream_format; AudioObjectPropertyAddress stream_format_address = { kAudioDevicePropertyStreamFormat, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster }; assert(ctx && max_channels); if (audiounit_get_output_device_id(&output_device_id) != CUBEB_OK) { return CUBEB_ERROR; } size = sizeof(stream_format); r = AudioObjectGetPropertyData(output_device_id, &stream_format_address, 0, NULL, &size, &stream_format); if (r != noErr) { PRINT_ERROR_CODE("AudioObjectPropertyAddress/StreamFormat", r); return CUBEB_ERROR; } *max_channels = stream_format.mChannelsPerFrame; #endif return CUBEB_OK; } static int audiounit_get_min_latency(cubeb * /* ctx */, cubeb_stream_params /* params */, uint32_t * latency_frames) { #if TARGET_OS_IPHONE //TODO: [[AVAudioSession sharedInstance] inputLatency] return CUBEB_ERROR_NOT_SUPPORTED; #else AudioValueRange latency_range; if (audiounit_get_acceptable_latency_range(&latency_range) != CUBEB_OK) { LOG("Could not get acceptable latency range."); return CUBEB_ERROR; } *latency_frames = std::max<uint32_t>(latency_range.mMinimum, SAFE_MIN_LATENCY_FRAMES); #endif return CUBEB_OK; } static int audiounit_get_preferred_sample_rate(cubeb * /* ctx */, uint32_t * rate) { #if TARGET_OS_IPHONE //TODO return CUBEB_ERROR_NOT_SUPPORTED; #else UInt32 size; OSStatus r; Float64 fsamplerate; AudioDeviceID output_device_id; AudioObjectPropertyAddress samplerate_address = { kAudioDevicePropertyNominalSampleRate, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster }; if (audiounit_get_output_device_id(&output_device_id) != CUBEB_OK) { return CUBEB_ERROR; } size = sizeof(fsamplerate); r = AudioObjectGetPropertyData(output_device_id, &samplerate_address, 0, NULL, &size, &fsamplerate); if (r != noErr) { return CUBEB_ERROR; } *rate = static_cast<uint32_t>(fsamplerate); #endif return CUBEB_OK; } static OSStatus audiounit_remove_device_listener(cubeb * context); static void audiounit_destroy(cubeb * ctx) { // Disabling this assert for bug 1083664 -- we seem to leak a stream // assert(ctx->active_streams == 0); { auto_lock lock(ctx->mutex); /* Unregister the callback if necessary. */ if(ctx->collection_changed_callback) { audiounit_remove_device_listener(ctx); } } ctx->~cubeb(); free(ctx); } static void audiounit_stream_destroy(cubeb_stream * stm); static int audio_stream_desc_init(AudioStreamBasicDescription * ss, const cubeb_stream_params * stream_params) { switch (stream_params->format) { case CUBEB_SAMPLE_S16LE: ss->mBitsPerChannel = 16; ss->mFormatFlags = kAudioFormatFlagIsSignedInteger; break; case CUBEB_SAMPLE_S16BE: ss->mBitsPerChannel = 16; ss->mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsBigEndian; break; case CUBEB_SAMPLE_FLOAT32LE: ss->mBitsPerChannel = 32; ss->mFormatFlags = kAudioFormatFlagIsFloat; break; case CUBEB_SAMPLE_FLOAT32BE: ss->mBitsPerChannel = 32; ss->mFormatFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsBigEndian; break; default: return CUBEB_ERROR_INVALID_FORMAT; } ss->mFormatID = kAudioFormatLinearPCM; ss->mFormatFlags |= kLinearPCMFormatFlagIsPacked; ss->mSampleRate = stream_params->rate; ss->mChannelsPerFrame = stream_params->channels; ss->mBytesPerFrame = (ss->mBitsPerChannel / 8) * ss->mChannelsPerFrame; ss->mFramesPerPacket = 1; ss->mBytesPerPacket = ss->mBytesPerFrame * ss->mFramesPerPacket; ss->mReserved = 0; return CUBEB_OK; } static int audiounit_create_unit(AudioUnit * unit, bool is_input, const cubeb_stream_params * /* stream_params */, cubeb_devid device) { AudioComponentDescription desc; AudioComponent comp; UInt32 enable; AudioDeviceID devid; OSStatus rv; desc.componentType = kAudioUnitType_Output; #if TARGET_OS_IPHONE bool use_default_output = false; desc.componentSubType = kAudioUnitSubType_RemoteIO; #else // Use the DefaultOutputUnit for output when no device is specified // so we retain automatic output device switching when the default // changes. Once we have complete support for device notifications // and switching, we can use the AUHAL for everything. bool use_default_output = device == NULL && !is_input; if (use_default_output) { desc.componentSubType = kAudioUnitSubType_DefaultOutput; } else { desc.componentSubType = kAudioUnitSubType_HALOutput; } #endif desc.componentManufacturer = kAudioUnitManufacturer_Apple; desc.componentFlags = 0; desc.componentFlagsMask = 0; comp = AudioComponentFindNext(NULL, &desc); if (comp == NULL) { LOG("Could not find matching audio hardware."); return CUBEB_ERROR; } rv = AudioComponentInstanceNew(comp, unit); if (rv != noErr) { PRINT_ERROR_CODE("AudioComponentInstanceNew", rv); return CUBEB_ERROR; } if (!use_default_output) { enable = 1; rv = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_EnableIO, is_input ? kAudioUnitScope_Input : kAudioUnitScope_Output, is_input ? AU_IN_BUS : AU_OUT_BUS, &enable, sizeof(UInt32)); if (rv != noErr) { PRINT_ERROR_CODE("AudioUnitSetProperty/kAudioOutputUnitProperty_EnableIO", rv); return CUBEB_ERROR; } enable = 0; rv = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_EnableIO, is_input ? kAudioUnitScope_Output : kAudioUnitScope_Input, is_input ? AU_OUT_BUS : AU_IN_BUS, &enable, sizeof(UInt32)); if (rv != noErr) { PRINT_ERROR_CODE("AudioUnitSetProperty/kAudioOutputUnitProperty_EnableIO", rv); return CUBEB_ERROR; } if (device == NULL) { assert(is_input); devid = audiounit_get_default_device_id(CUBEB_DEVICE_TYPE_INPUT); } else { devid = reinterpret_cast<intptr_t>(device); } rv = AudioUnitSetProperty(*unit, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, is_input ? AU_IN_BUS : AU_OUT_BUS, &devid, sizeof(AudioDeviceID)); if (rv != noErr) { PRINT_ERROR_CODE("AudioUnitSetProperty/kAudioOutputUnitProperty_CurrentDevice", rv); return CUBEB_ERROR; } } return CUBEB_OK; } static int audiounit_init_input_linear_buffer(cubeb_stream * stream, uint32_t capacity) { if (stream->input_desc.mFormatFlags & kAudioFormatFlagIsSignedInteger) { stream->input_linear_buffer = new auto_array_wrapper( new auto_array<short>(capacity * stream->input_buffer_frames * stream->input_desc.mChannelsPerFrame) ); } else { stream->input_linear_buffer = new auto_array_wrapper( new auto_array<float>(capacity * stream->input_buffer_frames * stream->input_desc.mChannelsPerFrame) ); } if (!stream->input_linear_buffer) { return CUBEB_ERROR; } assert(stream->input_linear_buffer->length() == 0); // Pre-buffer silence if needed if (capacity != 1) { size_t silence_size = stream->input_buffer_frames * stream->input_desc.mChannelsPerFrame; stream->input_linear_buffer->push_silence(silence_size); assert(stream->input_linear_buffer->length() == silence_size); } return CUBEB_OK; } static void audiounit_destroy_input_linear_buffer(cubeb_stream * stream) { delete stream->input_linear_buffer; } static uint32_t audiounit_clamp_latency(cubeb_stream * stm, uint32_t latency_frames) { // For the 1st stream set anything within safe min-max assert(stm->context->active_streams > 0); if (stm->context->active_streams == 1) { return std::max(std::min<uint32_t>(latency_frames, SAFE_MAX_LATENCY_FRAMES), SAFE_MIN_LATENCY_FRAMES); } // If more than one stream operates in parallel // allow only lower values of latency int r; UInt32 output_buffer_size = 0; UInt32 size = sizeof(output_buffer_size); if (stm->output_unit) { r = AudioUnitGetProperty(stm->output_unit, kAudioDevicePropertyBufferFrameSize, kAudioUnitScope_Output, AU_OUT_BUS, &output_buffer_size, &size); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitGetProperty/output/kAudioDevicePropertyBufferFrameSize", r); return 0; } output_buffer_size = std::max(std::min<uint32_t>(output_buffer_size, SAFE_MAX_LATENCY_FRAMES), SAFE_MIN_LATENCY_FRAMES); } UInt32 input_buffer_size = 0; if (stm->input_unit) { r = AudioUnitGetProperty(stm->input_unit, kAudioDevicePropertyBufferFrameSize, kAudioUnitScope_Input, AU_IN_BUS, &input_buffer_size, &size); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitGetProperty/input/kAudioDevicePropertyBufferFrameSize", r); return 0; } input_buffer_size = std::max(std::min<uint32_t>(input_buffer_size, SAFE_MAX_LATENCY_FRAMES), SAFE_MIN_LATENCY_FRAMES); } // Every following active streams can only set smaller latency UInt32 upper_latency_limit = 0; if (input_buffer_size != 0 && output_buffer_size != 0) { upper_latency_limit = std::min<uint32_t>(input_buffer_size, output_buffer_size); } else if (input_buffer_size != 0) { upper_latency_limit = input_buffer_size; } else if (output_buffer_size != 0) { upper_latency_limit = output_buffer_size; } else { upper_latency_limit = SAFE_MAX_LATENCY_FRAMES; } return std::max(std::min<uint32_t>(latency_frames, upper_latency_limit), SAFE_MIN_LATENCY_FRAMES); } /* * Change buffer size is prone to deadlock thus we change it * following the steps: * - register a listener for the buffer size property * - change the property * - wait until the listener is executed * - property has changed, remove the listener * */ static void buffer_size_changed_callback(void * inClientData, AudioUnit inUnit, AudioUnitPropertyID inPropertyID, AudioUnitScope inScope, AudioUnitElement inElement) { cubeb_stream * stm = (cubeb_stream *)inClientData; AudioUnit au = inUnit; AudioUnitScope au_scope = kAudioUnitScope_Input; AudioUnitElement au_element = inElement; const char * au_type = "output"; if (au == stm->input_unit) { au_scope = kAudioUnitScope_Output; au_type = "input"; } switch (inPropertyID) { case kAudioDevicePropertyBufferFrameSize: { if (inScope != au_scope) { break; } UInt32 new_buffer_size; UInt32 outSize = sizeof(UInt32); OSStatus r = AudioUnitGetProperty(au, kAudioDevicePropertyBufferFrameSize, au_scope, au_element, &new_buffer_size, &outSize); if (r != noErr) { LOG("(%p) Event: kAudioDevicePropertyBufferFrameSize: Cannot get current buffer size", stm); } else { LOG("(%p) Event: kAudioDevicePropertyBufferFrameSize: New %s buffer size = %d for scope %d", stm, au_type, new_buffer_size, inScope); } stm->buffer_size_change_state = true; break; } } } enum set_buffer_size_side { INPUT, OUTPUT, }; static int audiounit_set_buffer_size(cubeb_stream * stm, uint32_t new_size_frames, set_buffer_size_side set_side) { AudioUnit au = stm->output_unit; AudioUnitScope au_scope = kAudioUnitScope_Input; AudioUnitElement au_element = AU_OUT_BUS; const char * au_type = "output"; if (set_side == INPUT) { au = stm->input_unit; au_scope = kAudioUnitScope_Output; au_element = AU_IN_BUS; au_type = "input"; } uint32_t buffer_frames = 0; UInt32 size = sizeof(buffer_frames); int r = AudioUnitGetProperty(au, kAudioDevicePropertyBufferFrameSize, au_scope, au_element, &buffer_frames, &size); if (r != noErr) { if (set_side == INPUT) { PRINT_ERROR_CODE("AudioUnitGetProperty/input/kAudioDevicePropertyBufferFrameSize", r); } else { PRINT_ERROR_CODE("AudioUnitGetProperty/output/kAudioDevicePropertyBufferFrameSize", r); } return CUBEB_ERROR; } if (new_size_frames == buffer_frames) { LOG("(%p) No need to update %s buffer size already %u frames", stm, au_type, buffer_frames); return CUBEB_OK; } r = AudioUnitAddPropertyListener(au, kAudioDevicePropertyBufferFrameSize, buffer_size_changed_callback, stm); if (r != noErr) { if (set_side == INPUT) { PRINT_ERROR_CODE("AudioUnitAddPropertyListener/input/kAudioDevicePropertyBufferFrameSize", r); } else { PRINT_ERROR_CODE("AudioUnitAddPropertyListener/output/kAudioDevicePropertyBufferFrameSize", r); } return CUBEB_ERROR; } stm->buffer_size_change_state = false; r = AudioUnitSetProperty(au, kAudioDevicePropertyBufferFrameSize, au_scope, au_element, &new_size_frames, sizeof(new_size_frames)); if (r != noErr) { if (set_side == INPUT) { PRINT_ERROR_CODE("AudioUnitSetProperty/input/kAudioDevicePropertyBufferFrameSize", r); } else { PRINT_ERROR_CODE("AudioUnitSetProperty/output/kAudioDevicePropertyBufferFrameSize", r); } r = AudioUnitRemovePropertyListenerWithUserData(au, kAudioDevicePropertyBufferFrameSize, buffer_size_changed_callback, stm); if (r != noErr) { if (set_side == INPUT) { PRINT_ERROR_CODE("AudioUnitAddPropertyListener/input/kAudioDevicePropertyBufferFrameSize", r); } else { PRINT_ERROR_CODE("AudioUnitAddPropertyListener/output/kAudioDevicePropertyBufferFrameSize", r); } } return CUBEB_ERROR; } int count = 0; while (!stm->buffer_size_change_state && count++ < 30) { struct timespec req, rem; req.tv_sec = 0; req.tv_nsec = 100000000L; // 0.1 sec if (nanosleep(&req , &rem) < 0 ) { LOG("(%p) Warning: nanosleep call failed or interrupted. Remaining time %ld nano secs \n", stm, rem.tv_nsec); } LOG("(%p) audiounit_set_buffer_size : wait count = %d", stm, count); } r = AudioUnitRemovePropertyListenerWithUserData(au, kAudioDevicePropertyBufferFrameSize, buffer_size_changed_callback, stm); if (r != noErr) { return CUBEB_ERROR; if (set_side == INPUT) { PRINT_ERROR_CODE("AudioUnitAddPropertyListener/input/kAudioDevicePropertyBufferFrameSize", r); } else { PRINT_ERROR_CODE("AudioUnitAddPropertyListener/output/kAudioDevicePropertyBufferFrameSize", r); } } if (!stm->buffer_size_change_state && count >= 30) { LOG("(%p) Error, did not get buffer size change callback ...", stm); return CUBEB_ERROR; } LOG("(%p) %s buffer size changed to %u frames.", stm, au_type, new_size_frames); return CUBEB_OK; } static int audiounit_configure_input(cubeb_stream * stm) { int r = 0; UInt32 size; AURenderCallbackStruct aurcbs_in; LOG("(%p) Opening input side: rate %u, channels %u, format %d, latency in frames %u.", stm, stm->input_stream_params.rate, stm->input_stream_params.channels, stm->input_stream_params.format, stm->latency_frames); /* Get input device sample rate. */ AudioStreamBasicDescription input_hw_desc; size = sizeof(AudioStreamBasicDescription); r = AudioUnitGetProperty(stm->input_unit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, AU_IN_BUS, &input_hw_desc, &size); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitGetProperty/input/kAudioUnitProperty_StreamFormat", r); return CUBEB_ERROR; } stm->input_hw_rate = input_hw_desc.mSampleRate; LOG("(%p) Input device sampling rate: %.2f", stm, stm->input_hw_rate); /* Set format description according to the input params. */ r = audio_stream_desc_init(&stm->input_desc, &stm->input_stream_params); if (r != CUBEB_OK) { LOG("(%p) Setting format description for input failed.", stm); return r; } // Use latency to set buffer size stm->input_buffer_frames = stm->latency_frames; r = audiounit_set_buffer_size(stm, stm->input_buffer_frames, INPUT); if (r != CUBEB_OK) { LOG("(%p) Error in change input buffer size.", stm); return CUBEB_ERROR; } AudioStreamBasicDescription src_desc = stm->input_desc; /* Input AudioUnit must be configured with device's sample rate. we will resample inside input callback. */ src_desc.mSampleRate = stm->input_hw_rate; r = AudioUnitSetProperty(stm->input_unit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, AU_IN_BUS, &src_desc, sizeof(AudioStreamBasicDescription)); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitSetProperty/input/kAudioUnitProperty_StreamFormat", r); return CUBEB_ERROR; } /* Frames per buffer in the input callback. */ r = AudioUnitSetProperty(stm->input_unit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, AU_IN_BUS, &stm->input_buffer_frames, sizeof(UInt32)); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitSetProperty/input/kAudioUnitProperty_MaximumFramesPerSlice", r); return CUBEB_ERROR; } // Input only capacity unsigned int array_capacity = 1; if (has_output(stm)) { // Full-duplex increase capacity array_capacity = 8; } if (audiounit_init_input_linear_buffer(stm, array_capacity) != CUBEB_OK) { return CUBEB_ERROR; } assert(stm->input_unit != NULL); aurcbs_in.inputProc = audiounit_input_callback; aurcbs_in.inputProcRefCon = stm; r = AudioUnitSetProperty(stm->input_unit, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, AU_OUT_BUS, &aurcbs_in, sizeof(aurcbs_in)); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitSetProperty/input/kAudioOutputUnitProperty_SetInputCallback", r); return CUBEB_ERROR; } LOG("(%p) Input audiounit init successfully.", stm); return CUBEB_OK; } static int audiounit_configure_output(cubeb_stream * stm) { int r; AURenderCallbackStruct aurcbs_out; UInt32 size; LOG("(%p) Opening output side: rate %u, channels %u, format %d, latency in frames %u.", stm, stm->output_stream_params.rate, stm->output_stream_params.channels, stm->output_stream_params.format, stm->latency_frames); r = audio_stream_desc_init(&stm->output_desc, &stm->output_stream_params); if (r != CUBEB_OK) { LOG("(%p) Could not initialize the audio stream description.", stm); return r; } /* Get output device sample rate. */ AudioStreamBasicDescription output_hw_desc; size = sizeof(AudioStreamBasicDescription); memset(&output_hw_desc, 0, size); r = AudioUnitGetProperty(stm->output_unit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, AU_OUT_BUS, &output_hw_desc, &size); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitGetProperty/output/tkAudioUnitProperty_StreamFormat", r); return CUBEB_ERROR; } stm->output_hw_rate = output_hw_desc.mSampleRate; LOG("(%p) Output device sampling rate: %.2f", stm, output_hw_desc.mSampleRate); r = AudioUnitSetProperty(stm->output_unit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, AU_OUT_BUS, &stm->output_desc, sizeof(AudioStreamBasicDescription)); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitSetProperty/output/kAudioUnitProperty_StreamFormat", r); return CUBEB_ERROR; } r = audiounit_set_buffer_size(stm, stm->latency_frames, OUTPUT); if (r != CUBEB_OK) { LOG("(%p) Error in change output buffer size.", stm); return CUBEB_ERROR; } /* Frames per buffer in the input callback. */ r = AudioUnitSetProperty(stm->output_unit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, AU_OUT_BUS, &stm->latency_frames, sizeof(UInt32)); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitSetProperty/output/kAudioUnitProperty_MaximumFramesPerSlice", r); return CUBEB_ERROR; } assert(stm->output_unit != NULL); aurcbs_out.inputProc = audiounit_output_callback; aurcbs_out.inputProcRefCon = stm; r = AudioUnitSetProperty(stm->output_unit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Global, AU_OUT_BUS, &aurcbs_out, sizeof(aurcbs_out)); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitSetProperty/output/kAudioUnitProperty_SetRenderCallback", r); return CUBEB_ERROR; } LOG("(%p) Output audiounit init successfully.", stm); return CUBEB_OK; } static int audiounit_setup_stream(cubeb_stream * stm) { stm->mutex.assert_current_thread_owns(); int r = 0; if (has_input(stm)) { r = audiounit_create_unit(&stm->input_unit, true, &stm->input_stream_params, stm->input_device); if (r != CUBEB_OK) { LOG("(%p) AudioUnit creation for input failed.", stm); return r; } } if (has_output(stm)) { r = audiounit_create_unit(&stm->output_unit, false, &stm->output_stream_params, stm->output_device); if (r != CUBEB_OK) { LOG("(%p) AudioUnit creation for output failed.", stm); return r; } } /* Latency cannot change if another stream is operating in parallel. In this case * latecy is set to the other stream value. */ if (stm->context->active_streams > 1) { LOG("(%p) More than one active stream, use global latency.", stm); stm->latency_frames = stm->context->global_latency_frames; } else { /* Silently clamp the latency down to the platform default, because we * synthetize the clock from the callbacks, and we want the clock to update * often. */ stm->latency_frames = audiounit_clamp_latency(stm, stm->latency_frames); assert(stm->latency_frames); // Ungly error check audiounit_set_global_latency(stm, stm->latency_frames); } /* Setup Input Stream! */ if (has_input(stm)) { r = audiounit_configure_input(stm); if (r != CUBEB_OK) { LOG("(%p) Configure audiounit input failed.", stm); return r; } } /* Setup Output Stream! */ if (has_output(stm)) { r = audiounit_configure_output(stm); if (r != CUBEB_OK) { LOG("(%p) Configure audiounit output failed.", stm); return r; } } // Setting the latency doesn't work well for USB headsets (eg. plantronics). // Keep the default latency for now. #if 0 buffer_size = latency; /* Get the range of latency this particular device can work with, and clamp * the requested latency to this acceptable range. */ #if !TARGET_OS_IPHONE if (audiounit_get_acceptable_latency_range(&latency_range) != CUBEB_OK) { return CUBEB_ERROR; } if (buffer_size < (unsigned int) latency_range.mMinimum) { buffer_size = (unsigned int) latency_range.mMinimum; } else if (buffer_size > (unsigned int) latency_range.mMaximum) { buffer_size = (unsigned int) latency_range.mMaximum; } /** * Get the default buffer size. If our latency request is below the default, * set it. Otherwise, use the default latency. **/ size = sizeof(default_buffer_size); if (AudioUnitGetProperty(stm->output_unit, kAudioDevicePropertyBufferFrameSize, kAudioUnitScope_Output, 0, &default_buffer_size, &size) != 0) { return CUBEB_ERROR; } if (buffer_size < default_buffer_size) { /* Set the maximum number of frame that the render callback will ask for, * effectively setting the latency of the stream. This is process-wide. */ if (AudioUnitSetProperty(stm->output_unit, kAudioDevicePropertyBufferFrameSize, kAudioUnitScope_Output, 0, &buffer_size, sizeof(buffer_size)) != 0) { return CUBEB_ERROR; } } #else // TARGET_OS_IPHONE //TODO: [[AVAudioSession sharedInstance] inputLatency] // http://stackoverflow.com/questions/13157523/kaudiodevicepropertybufferframesize-replacement-for-ios #endif #endif /* We use a resampler because input AudioUnit operates * reliable only in the capture device sample rate. * Resampler will convert it to the user sample rate * and deliver it to the callback. */ uint32_t target_sample_rate; if (has_input(stm)) { target_sample_rate = stm->input_stream_params.rate; } else { assert(has_output(stm)); target_sample_rate = stm->output_stream_params.rate; } cubeb_stream_params input_unconverted_params; if (has_input(stm)) { input_unconverted_params = stm->input_stream_params; /* Use the rate of the input device. */ input_unconverted_params.rate = stm->input_hw_rate; } /* Create resampler. Output params are unchanged * because we do not need conversion on the output. */ stm->resampler = cubeb_resampler_create(stm, has_input(stm) ? &input_unconverted_params : NULL, has_output(stm) ? &stm->output_stream_params : NULL, target_sample_rate, stm->data_callback, stm->user_ptr, CUBEB_RESAMPLER_QUALITY_DESKTOP); if (!stm->resampler) { LOG("(%p) Could not create resampler.", stm); return CUBEB_ERROR; } if (stm->input_unit != NULL) { r = AudioUnitInitialize(stm->input_unit); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitInitialize/input", r); return CUBEB_ERROR; } } if (stm->output_unit != NULL) { r = AudioUnitInitialize(stm->output_unit); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitInitialize/output", r); return CUBEB_ERROR; } } if (stm->input_unit && stm->output_unit) { // According to the I/O hardware rate it is expected a specific pattern of callbacks // for example is input is 44100 and output is 48000 we expected no more than 2 // out callback in a row. stm->expected_output_callbacks_in_a_row = ceilf(stm->output_hw_rate / stm->input_hw_rate); } r = audiounit_install_device_changed_callback(stm); if (r != CUBEB_OK) { LOG("(%p) Could not install the device change callback.", stm); return r; } return CUBEB_OK; } static int audiounit_stream_init(cubeb * context, cubeb_stream ** stream, char const * /* stream_name */, cubeb_devid input_device, cubeb_stream_params * input_stream_params, cubeb_devid output_device, cubeb_stream_params * output_stream_params, unsigned int latency_frames, cubeb_data_callback data_callback, cubeb_state_callback state_callback, void * user_ptr) { cubeb_stream * stm; int r; assert(context); *stream = NULL; assert(latency_frames > 0); if (context->limit_streams && context->active_streams >= CUBEB_STREAM_MAX) { LOG("Reached the stream limit of %d", CUBEB_STREAM_MAX); return CUBEB_ERROR; } stm = (cubeb_stream *) calloc(1, sizeof(cubeb_stream)); assert(stm); // Placement new to call the ctors of cubeb_stream members. new (stm) cubeb_stream(); /* These could be different in the future if we have both * full-duplex stream and different devices for input vs output. */ stm->context = context; stm->data_callback = data_callback; stm->state_callback = state_callback; stm->user_ptr = user_ptr; stm->latency_frames = latency_frames; stm->device_changed_callback = NULL; if (input_stream_params) { stm->input_stream_params = *input_stream_params; stm->input_device = input_device; stm->is_default_input = input_device == nullptr || (audiounit_get_default_device_id(CUBEB_DEVICE_TYPE_INPUT) == reinterpret_cast<intptr_t>(input_device)); } if (output_stream_params) { stm->output_stream_params = *output_stream_params; stm->output_device = output_device; } /* Init data members where necessary */ stm->hw_latency_frames = UINT64_MAX; stm->switching_device = false; auto_lock context_lock(context->mutex); { // It's not critical to lock here, because no other thread has been started // yet, but it allows to assert that the lock has been taken in // `audiounit_setup_stream`. context->active_streams += 1; auto_lock lock(stm->mutex); r = audiounit_setup_stream(stm); } if (r != CUBEB_OK) { LOG("(%p) Could not setup the audiounit stream.", stm); audiounit_stream_destroy(stm); return r; } r = audiounit_install_system_changed_callback(stm); if (r != CUBEB_OK) { LOG("(%p) Could not install the device change callback.", stm); return r; } *stream = stm; LOG("Cubeb stream (%p) init successful.", stm); return CUBEB_OK; } static void audiounit_close_stream(cubeb_stream *stm) { stm->mutex.assert_current_thread_owns(); if (stm->input_unit) { AudioUnitUninitialize(stm->input_unit); AudioComponentInstanceDispose(stm->input_unit); } audiounit_destroy_input_linear_buffer(stm); if (stm->output_unit) { AudioUnitUninitialize(stm->output_unit); AudioComponentInstanceDispose(stm->output_unit); } cubeb_resampler_destroy(stm->resampler); } static void audiounit_stream_destroy(cubeb_stream * stm) { stm->shutdown = true; int r = audiounit_uninstall_system_changed_callback(stm); if (r != CUBEB_OK) { LOG("(%p) Could not uninstall the device changed callback", stm); } r = audiounit_uninstall_device_changed_callback(stm); if (r != CUBEB_OK) { LOG("(%p) Could not uninstall the device changed callback", stm); } auto_lock context_lock(stm->context->mutex); audiounit_stream_stop_internal(stm); // Execute close in serial queue to avoid collision // with reinit when un/plug devices dispatch_sync(stm->context->serial_queue, ^() { auto_lock lock(stm->mutex); audiounit_close_stream(stm); }); assert(stm->context->active_streams >= 1); stm->context->active_streams -= 1; LOG("Cubeb stream (%p) destroyed successful.", stm); stm->~cubeb_stream(); free(stm); } void audiounit_stream_start_internal(cubeb_stream * stm) { OSStatus r; if (stm->input_unit != NULL) { r = AudioOutputUnitStart(stm->input_unit); assert(r == 0); } if (stm->output_unit != NULL) { r = AudioOutputUnitStart(stm->output_unit); assert(r == 0); } } static int audiounit_stream_start(cubeb_stream * stm) { auto_lock context_lock(stm->context->mutex); stm->shutdown = false; stm->draining = false; audiounit_stream_start_internal(stm); stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_STARTED); LOG("Cubeb stream (%p) started successfully.", stm); return CUBEB_OK; } void audiounit_stream_stop_internal(cubeb_stream * stm) { OSStatus r; if (stm->input_unit != NULL) { r = AudioOutputUnitStop(stm->input_unit); assert(r == 0); } if (stm->output_unit != NULL) { r = AudioOutputUnitStop(stm->output_unit); assert(r == 0); } } static int audiounit_stream_stop(cubeb_stream * stm) { auto_lock context_lock(stm->context->mutex); stm->shutdown = true; audiounit_stream_stop_internal(stm); stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_STOPPED); LOG("Cubeb stream (%p) stopped successfully.", stm); return CUBEB_OK; } static int audiounit_stream_get_position(cubeb_stream * stm, uint64_t * position) { auto_lock lock(stm->mutex); *position = stm->frames_played; return CUBEB_OK; } int audiounit_stream_get_latency(cubeb_stream * stm, uint32_t * latency) { #if TARGET_OS_IPHONE //TODO return CUBEB_ERROR_NOT_SUPPORTED; #else auto_lock lock(stm->mutex); if (stm->hw_latency_frames == UINT64_MAX) { UInt32 size; uint32_t device_latency_frames, device_safety_offset; double unit_latency_sec; AudioDeviceID output_device_id; OSStatus r; AudioObjectPropertyAddress latency_address = { kAudioDevicePropertyLatency, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster }; AudioObjectPropertyAddress safety_offset_address = { kAudioDevicePropertySafetyOffset, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster }; r = audiounit_get_output_device_id(&output_device_id); if (r != noErr) { return CUBEB_ERROR; } size = sizeof(unit_latency_sec); r = AudioUnitGetProperty(stm->output_unit, kAudioUnitProperty_Latency, kAudioUnitScope_Global, 0, &unit_latency_sec, &size); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitGetProperty/kAudioUnitProperty_Latency", r); return CUBEB_ERROR; } size = sizeof(device_latency_frames); r = AudioObjectGetPropertyData(output_device_id, &latency_address, 0, NULL, &size, &device_latency_frames); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitGetPropertyData/latency_frames", r); return CUBEB_ERROR; } size = sizeof(device_safety_offset); r = AudioObjectGetPropertyData(output_device_id, &safety_offset_address, 0, NULL, &size, &device_safety_offset); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitGetPropertyData/safety_offset", r); return CUBEB_ERROR; } /* This part is fixed and depend on the stream parameter and the hardware. */ stm->hw_latency_frames = static_cast<uint32_t>(unit_latency_sec * stm->output_desc.mSampleRate) + device_latency_frames + device_safety_offset; } *latency = stm->hw_latency_frames + stm->current_latency_frames; return CUBEB_OK; #endif } static int audiounit_stream_get_volume(cubeb_stream * stm, float * volume) { assert(stm->output_unit); OSStatus r = AudioUnitGetParameter(stm->output_unit, kHALOutputParam_Volume, kAudioUnitScope_Global, 0, volume); if (r != noErr) { LOG("AudioUnitGetParameter/kHALOutputParam_Volume rv=%d", r); return CUBEB_ERROR; } return CUBEB_OK; } int audiounit_stream_set_volume(cubeb_stream * stm, float volume) { OSStatus r; r = AudioUnitSetParameter(stm->output_unit, kHALOutputParam_Volume, kAudioUnitScope_Global, 0, volume, 0); if (r != noErr) { PRINT_ERROR_CODE("AudioUnitSetParameter/kHALOutputParam_Volume", r); return CUBEB_ERROR; } return CUBEB_OK; } int audiounit_stream_set_panning(cubeb_stream * stm, float panning) { if (stm->output_desc.mChannelsPerFrame > 2) { return CUBEB_ERROR_INVALID_PARAMETER; } stm->panning.store(panning, std::memory_order_relaxed); return CUBEB_OK; } int audiounit_stream_get_current_device(cubeb_stream * stm, cubeb_device ** const device) { #if TARGET_OS_IPHONE //TODO return CUBEB_ERROR_NOT_SUPPORTED; #else OSStatus r; UInt32 size; UInt32 data; char strdata[4]; AudioDeviceID output_device_id; AudioDeviceID input_device_id; AudioObjectPropertyAddress datasource_address = { kAudioDevicePropertyDataSource, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster }; AudioObjectPropertyAddress datasource_address_input = { kAudioDevicePropertyDataSource, kAudioDevicePropertyScopeInput, kAudioObjectPropertyElementMaster }; *device = NULL; if (audiounit_get_output_device_id(&output_device_id) != CUBEB_OK) { return CUBEB_ERROR; } *device = new cubeb_device; if (!*device) { return CUBEB_ERROR; } PodZero(*device, 1); size = sizeof(UInt32); /* This fails with some USB headset, so simply return an empty string. */ r = AudioObjectGetPropertyData(output_device_id, &datasource_address, 0, NULL, &size, &data); if (r != noErr) { size = 0; data = 0; } (*device)->output_name = new char[size + 1]; if (!(*device)->output_name) { return CUBEB_ERROR; } // Turn the four chars packed into a uint32 into a string strdata[0] = (char)(data >> 24); strdata[1] = (char)(data >> 16); strdata[2] = (char)(data >> 8); strdata[3] = (char)(data); memcpy((*device)->output_name, strdata, size); (*device)->output_name[size] = '\0'; if (audiounit_get_input_device_id(&input_device_id) != CUBEB_OK) { return CUBEB_ERROR; } size = sizeof(UInt32); r = AudioObjectGetPropertyData(input_device_id, &datasource_address_input, 0, NULL, &size, &data); if (r != noErr) { LOG("(%p) Error when getting device !", stm); size = 0; data = 0; } (*device)->input_name = new char[size + 1]; if (!(*device)->input_name) { return CUBEB_ERROR; } // Turn the four chars packed into a uint32 into a string strdata[0] = (char)(data >> 24); strdata[1] = (char)(data >> 16); strdata[2] = (char)(data >> 8); strdata[3] = (char)(data); memcpy((*device)->input_name, strdata, size); (*device)->input_name[size] = '\0'; return CUBEB_OK; #endif } int audiounit_stream_device_destroy(cubeb_stream * /* stream */, cubeb_device * device) { delete [] device->output_name; delete [] device->input_name; delete device; return CUBEB_OK; } int audiounit_stream_register_device_changed_callback(cubeb_stream * stream, cubeb_device_changed_callback device_changed_callback) { /* Note: second register without unregister first causes 'nope' error. * Current implementation requires unregister before register a new cb. */ assert(!stream->device_changed_callback); auto_lock lock(stream->mutex); stream->device_changed_callback = device_changed_callback; return CUBEB_OK; } static OSStatus audiounit_get_devices(AudioObjectID ** devices, uint32_t * count) { OSStatus ret; UInt32 size = 0; AudioObjectPropertyAddress adr = { kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster }; ret = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &adr, 0, NULL, &size); if (ret != noErr) { return ret; } *count = static_cast<uint32_t>(size / sizeof(AudioObjectID)); if (size >= sizeof(AudioObjectID)) { if (*devices != NULL) { delete [] (*devices); } *devices = new AudioObjectID[*count]; PodZero(*devices, *count); ret = AudioObjectGetPropertyData(kAudioObjectSystemObject, &adr, 0, NULL, &size, (void *)*devices); if (ret != noErr) { delete [] (*devices); *devices = NULL; } } else { *devices = NULL; ret = -1; } return ret; } static char * audiounit_strref_to_cstr_utf8(CFStringRef strref) { CFIndex len, size; char * ret; if (strref == NULL) { return NULL; } len = CFStringGetLength(strref); size = CFStringGetMaximumSizeForEncoding(len, kCFStringEncodingUTF8); ret = static_cast<char *>(malloc(size)); if (!CFStringGetCString(strref, ret, size, kCFStringEncodingUTF8)) { free(ret); ret = NULL; } return ret; } static uint32_t audiounit_get_channel_count(AudioObjectID devid, AudioObjectPropertyScope scope) { AudioObjectPropertyAddress adr = { 0, scope, kAudioObjectPropertyElementMaster }; UInt32 size = 0; uint32_t i, ret = 0; adr.mSelector = kAudioDevicePropertyStreamConfiguration; if (AudioObjectGetPropertyDataSize(devid, &adr, 0, NULL, &size) == noErr && size > 0) { AudioBufferList * list = static_cast<AudioBufferList *>(alloca(size)); if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, list) == noErr) { for (i = 0; i < list->mNumberBuffers; i++) ret += list->mBuffers[i].mNumberChannels; } } return ret; } static void audiounit_get_available_samplerate(AudioObjectID devid, AudioObjectPropertyScope scope, uint32_t * min, uint32_t * max, uint32_t * def) { AudioObjectPropertyAddress adr = { 0, scope, kAudioObjectPropertyElementMaster }; adr.mSelector = kAudioDevicePropertyNominalSampleRate; if (AudioObjectHasProperty(devid, &adr)) { UInt32 size = sizeof(Float64); Float64 fvalue = 0.0; if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &fvalue) == noErr) { *def = fvalue; } } adr.mSelector = kAudioDevicePropertyAvailableNominalSampleRates; UInt32 size = 0; AudioValueRange range; if (AudioObjectHasProperty(devid, &adr) && AudioObjectGetPropertyDataSize(devid, &adr, 0, NULL, &size) == noErr) { uint32_t i, count = size / sizeof(AudioValueRange); AudioValueRange * ranges = new AudioValueRange[count]; range.mMinimum = 9999999999.0; range.mMaximum = 0.0; if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, ranges) == noErr) { for (i = 0; i < count; i++) { if (ranges[i].mMaximum > range.mMaximum) range.mMaximum = ranges[i].mMaximum; if (ranges[i].mMinimum < range.mMinimum) range.mMinimum = ranges[i].mMinimum; } } delete [] ranges; *max = static_cast<uint32_t>(range.mMaximum); *min = static_cast<uint32_t>(range.mMinimum); } else { *min = *max = 0; } } static UInt32 audiounit_get_device_presentation_latency(AudioObjectID devid, AudioObjectPropertyScope scope) { AudioObjectPropertyAddress adr = { 0, scope, kAudioObjectPropertyElementMaster }; UInt32 size, dev, stream = 0, offset; AudioStreamID sid[1]; adr.mSelector = kAudioDevicePropertyLatency; size = sizeof(UInt32); if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &dev) != noErr) { dev = 0; } adr.mSelector = kAudioDevicePropertyStreams; size = sizeof(sid); if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, sid) == noErr) { adr.mSelector = kAudioStreamPropertyLatency; size = sizeof(UInt32); AudioObjectGetPropertyData(sid[0], &adr, 0, NULL, &size, &stream); } adr.mSelector = kAudioDevicePropertySafetyOffset; size = sizeof(UInt32); if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &offset) != noErr) { offset = 0; } return dev + stream + offset; } static cubeb_device_info * audiounit_create_device_from_hwdev(AudioObjectID devid, cubeb_device_type type) { AudioObjectPropertyAddress adr = { 0, 0, kAudioObjectPropertyElementMaster }; UInt32 size, ch, latency; cubeb_device_info * ret; CFStringRef str = NULL; AudioValueRange range; if (type == CUBEB_DEVICE_TYPE_OUTPUT) { adr.mScope = kAudioDevicePropertyScopeOutput; } else if (type == CUBEB_DEVICE_TYPE_INPUT) { adr.mScope = kAudioDevicePropertyScopeInput; } else { return NULL; } ch = audiounit_get_channel_count(devid, adr.mScope); if (ch == 0) { return NULL; } ret = new cubeb_device_info; PodZero(ret, 1); size = sizeof(CFStringRef); adr.mSelector = kAudioDevicePropertyDeviceUID; if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &str) == noErr && str != NULL) { ret->device_id = audiounit_strref_to_cstr_utf8(str); ret->devid = (cubeb_devid)(size_t)devid; ret->group_id = strdup(ret->device_id); CFRelease(str); } size = sizeof(CFStringRef); adr.mSelector = kAudioObjectPropertyName; if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &str) == noErr && str != NULL) { UInt32 ds; size = sizeof(UInt32); adr.mSelector = kAudioDevicePropertyDataSource; if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &ds) == noErr) { CFStringRef dsname; AudioValueTranslation trl = { &ds, sizeof(ds), &dsname, sizeof(dsname) }; adr.mSelector = kAudioDevicePropertyDataSourceNameForIDCFString; size = sizeof(AudioValueTranslation); // If there is a datasource for this device, use it instead of the device // name. if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &trl) == noErr) { CFRelease(str); str = dsname; } } ret->friendly_name = audiounit_strref_to_cstr_utf8(str); CFRelease(str); } size = sizeof(CFStringRef); adr.mSelector = kAudioObjectPropertyManufacturer; if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &str) == noErr && str != NULL) { ret->vendor_name = audiounit_strref_to_cstr_utf8(str); CFRelease(str); } ret->type = type; ret->state = CUBEB_DEVICE_STATE_ENABLED; ret->preferred = (devid == audiounit_get_default_device_id(type)) ? CUBEB_DEVICE_PREF_ALL : CUBEB_DEVICE_PREF_NONE; ret->max_channels = ch; ret->format = (cubeb_device_fmt)CUBEB_DEVICE_FMT_ALL; /* CoreAudio supports All! */ /* kAudioFormatFlagsAudioUnitCanonical is deprecated, prefer floating point */ ret->default_format = CUBEB_DEVICE_FMT_F32NE; audiounit_get_available_samplerate(devid, adr.mScope, &ret->min_rate, &ret->max_rate, &ret->default_rate); latency = audiounit_get_device_presentation_latency(devid, adr.mScope); adr.mSelector = kAudioDevicePropertyBufferFrameSizeRange; size = sizeof(AudioValueRange); if (AudioObjectGetPropertyData(devid, &adr, 0, NULL, &size, &range) == noErr) { ret->latency_lo = latency + range.mMinimum; ret->latency_hi = latency + range.mMaximum; } else { ret->latency_lo = 10 * ret->default_rate / 1000; /* Default to 10ms */ ret->latency_hi = 100 * ret->default_rate / 1000; /* Default to 100ms */ } return ret; } static int audiounit_enumerate_devices(cubeb * /* context */, cubeb_device_type type, cubeb_device_collection ** collection) { AudioObjectID * hwdevs = NULL; uint32_t i, hwdevcount = 0; OSStatus err; if ((err = audiounit_get_devices(&hwdevs, &hwdevcount)) != noErr) { return CUBEB_ERROR; } *collection = static_cast<cubeb_device_collection *>(malloc(sizeof(cubeb_device_collection) + sizeof(cubeb_device_info*) * (hwdevcount > 0 ? hwdevcount - 1 : 0))); (*collection)->count = 0; if (hwdevcount > 0) { cubeb_device_info * cur; if (type & CUBEB_DEVICE_TYPE_OUTPUT) { for (i = 0; i < hwdevcount; i++) { if ((cur = audiounit_create_device_from_hwdev(hwdevs[i], CUBEB_DEVICE_TYPE_OUTPUT)) != NULL) (*collection)->device[(*collection)->count++] = cur; } } if (type & CUBEB_DEVICE_TYPE_INPUT) { for (i = 0; i < hwdevcount; i++) { if ((cur = audiounit_create_device_from_hwdev(hwdevs[i], CUBEB_DEVICE_TYPE_INPUT)) != NULL) (*collection)->device[(*collection)->count++] = cur; } } } delete [] hwdevs; return CUBEB_OK; } /* qsort compare method. */ int compare_devid(const void * a, const void * b) { return (*(AudioObjectID*)a - *(AudioObjectID*)b); } static uint32_t audiounit_get_devices_of_type(cubeb_device_type devtype, AudioObjectID ** devid_array) { assert(devid_array == NULL || *devid_array == NULL); AudioObjectPropertyAddress adr = { kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster }; UInt32 size = 0; OSStatus ret = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &adr, 0, NULL, &size); if (ret != noErr) { return 0; } /* Total number of input and output devices. */ uint32_t count = (uint32_t)(size / sizeof(AudioObjectID)); AudioObjectID devices[count]; ret = AudioObjectGetPropertyData(kAudioObjectSystemObject, &adr, 0, NULL, &size, &devices); if (ret != noErr) { return 0; } /* Expected sorted but did not find anything in the docs. */ qsort(devices, count, sizeof(AudioObjectID), compare_devid); if (devtype == (CUBEB_DEVICE_TYPE_INPUT | CUBEB_DEVICE_TYPE_OUTPUT)) { if (devid_array) { *devid_array = new AudioObjectID[count]; assert(*devid_array); memcpy(*devid_array, &devices, count * sizeof(AudioObjectID)); } return count; } AudioObjectPropertyScope scope = (devtype == CUBEB_DEVICE_TYPE_INPUT) ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput; uint32_t dev_count = 0; AudioObjectID devices_in_scope[count]; for(uint32_t i = 0; i < count; ++i) { /* For device in the given scope channel must be > 0. */ if (audiounit_get_channel_count(devices[i], scope) > 0) { devices_in_scope[dev_count] = devices[i]; ++dev_count; } } if (devid_array && dev_count > 0) { *devid_array = new AudioObjectID[dev_count]; assert(*devid_array); memcpy(*devid_array, &devices_in_scope, dev_count * sizeof(AudioObjectID)); } return dev_count; } static uint32_t audiounit_equal_arrays(AudioObjectID * left, AudioObjectID * right, uint32_t size) { /* Expected sorted arrays. */ for (uint32_t i = 0; i < size; ++i) { if (left[i] != right[i]) { return 0; } } return 1; } static OSStatus audiounit_collection_changed_callback(AudioObjectID /* inObjectID */, UInt32 /* inNumberAddresses */, const AudioObjectPropertyAddress * /* inAddresses */, void * inClientData) { cubeb * context = static_cast<cubeb *>(inClientData); auto_lock lock(context->mutex); if (context->collection_changed_callback == NULL) { /* Listener removed while waiting in mutex, abort. */ return noErr; } /* Differentiate input from output changes. */ if (context->collection_changed_devtype == CUBEB_DEVICE_TYPE_INPUT || context->collection_changed_devtype == CUBEB_DEVICE_TYPE_OUTPUT) { AudioObjectID * devices = NULL; uint32_t new_number_of_devices = audiounit_get_devices_of_type(context->collection_changed_devtype, &devices); /* When count is the same examine the devid for the case of coalescing. */ if (context->devtype_device_count == new_number_of_devices && audiounit_equal_arrays(devices, context->devtype_device_array, new_number_of_devices)) { /* Device changed for the other scope, ignore. */ delete [] devices; return noErr; } /* Device on desired scope changed, reset counter and array. */ context->devtype_device_count = new_number_of_devices; /* Free the old array before replace. */ delete [] context->devtype_device_array; context->devtype_device_array = devices; } context->collection_changed_callback(context, context->collection_changed_user_ptr); return noErr; } static OSStatus audiounit_add_device_listener(cubeb * context, cubeb_device_type devtype, cubeb_device_collection_changed_callback collection_changed_callback, void * user_ptr) { /* Note: second register without unregister first causes 'nope' error. * Current implementation requires unregister before register a new cb. */ assert(context->collection_changed_callback == NULL); AudioObjectPropertyAddress devAddr; devAddr.mSelector = kAudioHardwarePropertyDevices; devAddr.mScope = kAudioObjectPropertyScopeGlobal; devAddr.mElement = kAudioObjectPropertyElementMaster; OSStatus ret = AudioObjectAddPropertyListener(kAudioObjectSystemObject, &devAddr, audiounit_collection_changed_callback, context); if (ret == noErr) { /* Expected zero after unregister. */ assert(context->devtype_device_count == 0); assert(context->devtype_device_array == NULL); /* Listener works for input and output. * When requested one of them we need to differentiate. */ if (devtype == CUBEB_DEVICE_TYPE_INPUT || devtype == CUBEB_DEVICE_TYPE_OUTPUT) { /* Used to differentiate input from output device changes. */ context->devtype_device_count = audiounit_get_devices_of_type(devtype, &context->devtype_device_array); } context->collection_changed_devtype = devtype; context->collection_changed_callback = collection_changed_callback; context->collection_changed_user_ptr = user_ptr; } return ret; } static OSStatus audiounit_remove_device_listener(cubeb * context) { AudioObjectPropertyAddress devAddr; devAddr.mSelector = kAudioHardwarePropertyDevices; devAddr.mScope = kAudioObjectPropertyScopeGlobal; devAddr.mElement = kAudioObjectPropertyElementMaster; /* Note: unregister a non registered cb is not a problem, not checking. */ OSStatus ret = AudioObjectRemovePropertyListener(kAudioObjectSystemObject, &devAddr, audiounit_collection_changed_callback, context); if (ret == noErr) { /* Reset all values. */ context->collection_changed_devtype = CUBEB_DEVICE_TYPE_UNKNOWN; context->collection_changed_callback = NULL; context->collection_changed_user_ptr = NULL; context->devtype_device_count = 0; if (context->devtype_device_array) { delete [] context->devtype_device_array; context->devtype_device_array = NULL; } } return ret; } int audiounit_register_device_collection_changed(cubeb * context, cubeb_device_type devtype, cubeb_device_collection_changed_callback collection_changed_callback, void * user_ptr) { OSStatus ret; auto_lock lock(context->mutex); if (collection_changed_callback) { ret = audiounit_add_device_listener(context, devtype, collection_changed_callback, user_ptr); } else { ret = audiounit_remove_device_listener(context); } return (ret == noErr) ? CUBEB_OK : CUBEB_ERROR; } cubeb_ops const audiounit_ops = { /*.init =*/ audiounit_init, /*.get_backend_id =*/ audiounit_get_backend_id, /*.get_max_channel_count =*/ audiounit_get_max_channel_count, /*.get_min_latency =*/ audiounit_get_min_latency, /*.get_preferred_sample_rate =*/ audiounit_get_preferred_sample_rate, /*.enumerate_devices =*/ audiounit_enumerate_devices, /*.destroy =*/ audiounit_destroy, /*.stream_init =*/ audiounit_stream_init, /*.stream_destroy =*/ audiounit_stream_destroy, /*.stream_start =*/ audiounit_stream_start, /*.stream_stop =*/ audiounit_stream_stop, /*.stream_get_position =*/ audiounit_stream_get_position, /*.stream_get_latency =*/ audiounit_stream_get_latency, /*.stream_set_volume =*/ audiounit_stream_set_volume, /*.stream_set_panning =*/ audiounit_stream_set_panning, /*.stream_get_current_device =*/ audiounit_stream_get_current_device, /*.stream_device_destroy =*/ audiounit_stream_device_destroy, /*.stream_register_device_changed_callback =*/ audiounit_stream_register_device_changed_callback, /*.register_device_collection_changed =*/ audiounit_register_device_collection_changed };