/*
* Copyright © 2011 Mozilla Foundation
*
* This program is made available under an ISC-style license. See the
* accompanying file LICENSE for details.
*/
#undef NDEBUG
#include <AudioUnit/AudioUnit.h>
#include <TargetConditionals.h>
#include <assert.h>
#include <mach/mach_time.h>
#include <pthread.h>
#include <stdlib.h>
#if !TARGET_OS_IPHONE
#include <AvailabilityMacros.h>
#include <CoreAudio/AudioHardware.h>
#include <CoreAudio/HostTime.h>
#include <CoreFoundation/CoreFoundation.h>
#endif
#include "cubeb-internal.h"
#include "cubeb/cubeb.h"
#include "cubeb_mixer.h"
#include <AudioToolbox/AudioToolbox.h>
#include <CoreAudio/CoreAudioTypes.h>
#if !TARGET_OS_IPHONE
#include "cubeb_osx_run_loop.h"
#endif
#include "cubeb_resampler.h"
#include "cubeb_ring_array.h"
#include <algorithm>
#include <atomic>
#include <set>
#include <string>
#include <sys/time.h>
#include <vector>
using namespace std;
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101000
typedef UInt32 AudioFormatFlags;
#endif
#if TARGET_OS_IPHONE
typedef UInt32 AudioDeviceID;
typedef UInt32 AudioObjectID;
const UInt32 kAudioObjectUnknown = 0;
#define AudioGetCurrentHostTime mach_absolute_time
#endif
#define AU_OUT_BUS 0
#define AU_IN_BUS 1
const char * DISPATCH_QUEUE_LABEL =
"org.mozilla.cubeb";
const char * PRIVATE_AGGREGATE_DEVICE_NAME =
"CubebAggregateDevice";
#ifdef ALOGV
#undef ALOGV
#endif
#define ALOGV(msg, ...) \
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), \
^{ \
LOGV(msg,
##__VA_ARGS__); \
})
#ifdef ALOG
#undef ALOG
#endif
#define ALOG(msg, ...) \
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), \
^{ \
LOG(msg,
##__VA_ARGS__); \
})
#if !TARGET_OS_IPHONE
/* 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 = 128;
const uint32_t SAFE_MAX_LATENCY_FRAMES = 512;
const AudioObjectPropertyAddress DEFAULT_INPUT_DEVICE_PROPERTY_ADDRESS = {
kAudioHardwarePropertyDefaultInputDevice, kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMain};
const AudioObjectPropertyAddress DEFAULT_OUTPUT_DEVICE_PROPERTY_ADDRESS = {
kAudioHardwarePropertyDefaultOutputDevice, kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMain};
const AudioObjectPropertyAddress DEVICE_IS_ALIVE_PROPERTY_ADDRESS = {
kAudioDevicePropertyDeviceIsAlive, kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMain};
const AudioObjectPropertyAddress DEVICES_PROPERTY_ADDRESS = {
kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMain};
const AudioObjectPropertyAddress INPUT_DATA_SOURCE_PROPERTY_ADDRESS = {
kAudioDevicePropertyDataSource, kAudioDevicePropertyScopeInput,
kAudioObjectPropertyElementMain};
const AudioObjectPropertyAddress OUTPUT_DATA_SOURCE_PROPERTY_ADDRESS = {
kAudioDevicePropertyDataSource, kAudioDevicePropertyScopeOutput,
kAudioObjectPropertyElementMain};
#endif
typedef uint32_t device_flags_value;
enum device_flags {
DEV_UNKNOWN = 0x00,
/* Unknown */
DEV_INPUT = 0x01,
/* Record device like mic */
DEV_OUTPUT = 0x02,
/* Playback device like speakers */
DEV_SYSTEM_DEFAULT = 0x04,
/* System default device */
DEV_SELECTED_DEFAULT =
0x08,
/* User selected to use the system default device */
};
void
audiounit_stream_stop_internal(cubeb_stream * stm);
static int
audiounit_stream_start_internal(cubeb_stream * stm);
static void
audiounit_close_stream(cubeb_stream * stm);
static int
audiounit_setup_stream(cubeb_stream * stm);
#if !TARGET_OS_IPHONE
static vector<AudioObjectID>
audiounit_get_devices_of_type(cubeb_device_type devtype);
static UInt32
audiounit_get_device_presentation_latency(AudioObjectID devid,
AudioObjectPropertyScope scope);
static AudioObjectID
audiounit_get_default_device_id(cubeb_device_type type);
static int
audiounit_uninstall_device_changed_callback(cubeb_stream * stm);
static int
audiounit_uninstall_system_changed_callback(cubeb_stream * stm);
#endif
static void
audiounit_reinit_stream_async(cubeb_stream * stm, device_flags_value flags);
extern cubeb_ops
const audiounit_ops;
struct cubeb {
cubeb_ops
const * ops = &audiounit_ops;
owned_critical_section mutex;
int active_streams = 0;
uint32_t global_latency_frames = 0;
cubeb_device_collection_changed_callback input_collection_changed_callback =
nullptr;
void * input_collection_changed_user_ptr = nullptr;
cubeb_device_collection_changed_callback output_collection_changed_callback =
nullptr;
void * output_collection_changed_user_ptr = nullptr;
#if !TARGET_OS_IPHONE
// Store list of devices to detect changes
vector<AudioObjectID> input_device_array;
vector<AudioObjectID> output_device_array;
#endif
// The queue should be released when it’s no longer needed.
dispatch_queue_t serial_queue =
dispatch_queue_create(DISPATCH_QUEUE_LABEL, DISPATCH_QUEUE_SERIAL);
// Current used channel layout
atomic<cubeb_channel_layout> layout{CUBEB_LAYOUT_UNDEFINED};
uint32_t channels = 0;
};
static unique_ptr<AudioChannelLayout, decltype(&free)>
make_sized_audio_channel_layout(size_t sz)
{
assert(sz >=
sizeof(AudioChannelLayout));
AudioChannelLayout * acl =
reinterpret_cast<AudioChannelLayout *>(calloc(1, sz));
assert(acl);
// Assert the allocation works.
return unique_ptr<AudioChannelLayout, decltype(&free)>(acl, free);
}
enum class io_side {
INPUT,
OUTPUT,
};
static char const *
to_string(io_side side)
{
switch (side) {
case io_side::INPUT:
return "input";
case io_side::OUTPUT:
return "output";
}
}
struct device_info {
AudioDeviceID id = kAudioObjectUnknown;
device_flags_value flags = DEV_UNKNOWN;
};
#if !TARGET_OS_IPHONE
struct property_listener {
AudioDeviceID device_id;
const AudioObjectPropertyAddress * property_address;
AudioObjectPropertyListenerProc callback;
cubeb_stream * stream;
property_listener(AudioDeviceID id,
const AudioObjectPropertyAddress * address,
AudioObjectPropertyListenerProc proc, cubeb_stream * stm)
: device_id(id), property_address(address), callback(proc), stream(stm)
{
}
};
#endif
struct cubeb_stream {
explicit cubeb_stream(cubeb * context);
/* Note: Must match cubeb_stream layout in cubeb.c. */
cubeb * context;
void * user_ptr = nullptr;
/**/
cubeb_data_callback data_callback = nullptr;
cubeb_state_callback state_callback = nullptr;
cubeb_device_changed_callback device_changed_callback = nullptr;
owned_critical_section device_changed_callback_lock;
/* Stream creation parameters */
cubeb_stream_params input_stream_params = {CUBEB_SAMPLE_FLOAT32NE, 0, 0,
CUBEB_LAYOUT_UNDEFINED,
CUBEB_STREAM_PREF_NONE};
cubeb_stream_params output_stream_params = {CUBEB_SAMPLE_FLOAT32NE, 0, 0,
CUBEB_LAYOUT_UNDEFINED,
CUBEB_STREAM_PREF_NONE};
device_info input_device;
device_info output_device;
/* Format descriptions */
AudioStreamBasicDescription input_desc;
AudioStreamBasicDescription output_desc;
/* I/O AudioUnits */
AudioUnit input_unit = nullptr;
AudioUnit output_unit = nullptr;
/* I/O device sample rate */
Float64 input_hw_rate = 0;
Float64 output_hw_rate = 0;
/* Expected I/O thread interleave,
* calculated from I/O hw rate. */
int expected_output_callbacks_in_a_row = 0;
owned_critical_section mutex;
// Hold the input samples in every input callback iteration.
// Only accessed on input/output callback thread and during initial configure.
unique_ptr<auto_array_wrapper> input_linear_buffer;
/* Frame counters */
atomic<uint64_t> frames_played{0};
uint64_t frames_queued = 0;
// How many frames got read from the input since the stream started (includes
// padded silence)
atomic<int64_t> frames_read{0};
// How many frames got written to the output device since the stream started
atomic<int64_t> frames_written{0};
atomic<
bool> shutdown{
true};
atomic<
bool> draining{
false};
atomic<
bool> reinit_pending{
false};
atomic<
bool> destroy_pending{
false};
/* Latency requested by the user. */
uint32_t latency_frames = 0;
atomic<uint32_t> current_latency_frames{0};
atomic<uint32_t> total_output_latency_frames{0};
unique_ptr<cubeb_resampler, decltype(&cubeb_resampler_destroy)> resampler;
/* This is true if a device change callback is currently running. */
atomic<
bool> switching_device{
false};
atomic<
bool> buffer_size_change_state{
false};
#if !TARGET_OS_IPHONE
AudioDeviceID aggregate_device_id =
kAudioObjectUnknown;
// the aggregate device id
AudioObjectID plugin_id =
kAudioObjectUnknown;
// used to create aggregate device
#endif
/* Mixer interface */
unique_ptr<cubeb_mixer, decltype(&cubeb_mixer_destroy)> mixer;
/* Buffer where remixing/resampling will occur when upmixing is required */
/* Only accessed from callback thread */
unique_ptr<uint8_t[]> temp_buffer;
size_t temp_buffer_size = 0;
// size in bytes.
#if !TARGET_OS_IPHONE
/* Listeners indicating what system events are monitored. */
unique_ptr<property_listener> default_input_listener;
unique_ptr<property_listener> default_output_listener;
unique_ptr<property_listener> input_alive_listener;
unique_ptr<property_listener> input_source_listener;
unique_ptr<property_listener> output_source_listener;
#endif
};
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;
}
cubeb_channel
channel_label_to_cubeb_channel(UInt32 label)
{
switch (label) {
case kAudioChannelLabel_Left:
return CHANNEL_FRONT_LEFT;
case kAudioChannelLabel_Right:
return CHANNEL_FRONT_RIGHT;
case kAudioChannelLabel_Center:
return CHANNEL_FRONT_CENTER;
case kAudioChannelLabel_LFEScreen:
return CHANNEL_LOW_FREQUENCY;
case kAudioChannelLabel_LeftSurround:
return CHANNEL_BACK_LEFT;
case kAudioChannelLabel_RightSurround:
return CHANNEL_BACK_RIGHT;
case kAudioChannelLabel_LeftCenter:
return CHANNEL_FRONT_LEFT_OF_CENTER;
case kAudioChannelLabel_RightCenter:
return CHANNEL_FRONT_RIGHT_OF_CENTER;
case kAudioChannelLabel_CenterSurround:
return CHANNEL_BACK_CENTER;
case kAudioChannelLabel_LeftSurroundDirect:
return CHANNEL_SIDE_LEFT;
case kAudioChannelLabel_RightSurroundDirect:
return CHANNEL_SIDE_RIGHT;
case kAudioChannelLabel_TopCenterSurround:
return CHANNEL_TOP_CENTER;
case kAudioChannelLabel_VerticalHeightLeft:
return CHANNEL_TOP_FRONT_LEFT;
case kAudioChannelLabel_VerticalHeightCenter:
return CHANNEL_TOP_FRONT_CENTER;
case kAudioChannelLabel_VerticalHeightRight:
return CHANNEL_TOP_FRONT_RIGHT;
case kAudioChannelLabel_TopBackLeft:
return CHANNEL_TOP_BACK_LEFT;
case kAudioChannelLabel_TopBackCenter:
return CHANNEL_TOP_BACK_CENTER;
case kAudioChannelLabel_TopBackRight:
return CHANNEL_TOP_BACK_RIGHT;
default:
return CHANNEL_UNKNOWN;
}
}
AudioChannelLabel
cubeb_channel_to_channel_label(cubeb_channel channel)
{
switch (channel) {
case CHANNEL_FRONT_LEFT:
return kAudioChannelLabel_Left;
case CHANNEL_FRONT_RIGHT:
return kAudioChannelLabel_Right;
case CHANNEL_FRONT_CENTER:
return kAudioChannelLabel_Center;
case CHANNEL_LOW_FREQUENCY:
return kAudioChannelLabel_LFEScreen;
case CHANNEL_BACK_LEFT:
return kAudioChannelLabel_LeftSurround;
case CHANNEL_BACK_RIGHT:
return kAudioChannelLabel_RightSurround;
case CHANNEL_FRONT_LEFT_OF_CENTER:
return kAudioChannelLabel_LeftCenter;
case CHANNEL_FRONT_RIGHT_OF_CENTER:
return kAudioChannelLabel_RightCenter;
case CHANNEL_BACK_CENTER:
return kAudioChannelLabel_CenterSurround;
case CHANNEL_SIDE_LEFT:
return kAudioChannelLabel_LeftSurroundDirect;
case CHANNEL_SIDE_RIGHT:
return kAudioChannelLabel_RightSurroundDirect;
case CHANNEL_TOP_CENTER:
return kAudioChannelLabel_TopCenterSurround;
case CHANNEL_TOP_FRONT_LEFT:
return kAudioChannelLabel_VerticalHeightLeft;
case CHANNEL_TOP_FRONT_CENTER:
return kAudioChannelLabel_VerticalHeightCenter;
case CHANNEL_TOP_FRONT_RIGHT:
return kAudioChannelLabel_VerticalHeightRight;
case CHANNEL_TOP_BACK_LEFT:
return kAudioChannelLabel_TopBackLeft;
case CHANNEL_TOP_BACK_CENTER:
return kAudioChannelLabel_TopBackCenter;
case CHANNEL_TOP_BACK_RIGHT:
return kAudioChannelLabel_TopBackRight;
default:
return kAudioChannelLabel_Unknown;
}
}
bool
is_common_sample_rate(Float64 sample_rate)
{
/* Some commonly used sample rates and their multiples and divisors. */
return sample_rate == 8000 || sample_rate == 16000 || sample_rate == 22050 ||
sample_rate == 32000 || sample_rate == 44100 || sample_rate == 48000 ||
sample_rate == 88200 || sample_rate == 96000;
}
uint64_t
ConvertHostTimeToNanos(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;
}
static void
audiounit_increment_active_streams(cubeb * ctx)
{
ctx->mutex.assert_current_thread_owns();
ctx->active_streams += 1;
}
static void
audiounit_decrement_active_streams(cubeb * ctx)
{
ctx->mutex.assert_current_thread_owns();
ctx->active_streams -= 1;
}
static int
audiounit_active_streams(cubeb * ctx)
{
ctx->mutex.assert_current_thread_owns();
return ctx->active_streams;
}
static void
audiounit_set_global_latency(cubeb * ctx, uint32_t latency_frames)
{
ctx->mutex.assert_current_thread_owns();
assert(audiounit_active_streams(ctx) == 1);
ctx->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) {
LOG(
"AudioUnitRender rv=%d", r);
if (r != kAudioUnitErr_CannotDoInCurrentContext) {
return r;
}
if (stm->output_unit) {
// kAudioUnitErr_CannotDoInCurrentContext is returned when using a BT
// headset and the profile is changed from A2DP to HFP/HSP. The previous
// output device is no longer valid and must be reset.
audiounit_reinit_stream_async(stm, DEV_INPUT | DEV_OUTPUT);
}
// For now state that no error occurred and feed silence, stream will be
// resumed once reinit has completed.
ALOGV(
"(%p) input: reinit pending feeding silence instead", stm);
stm->input_linear_buffer->push_silence(input_frames *
stm->input_desc.mChannelsPerFrame);
}
else {
/* Copy input data in linear buffer. */
stm->input_linear_buffer->push(input_buffer_list.mBuffers[0].mData,
input_frames *
stm->input_desc.mChannelsPerFrame);
}
/* Advance input frame counter. */
assert(input_frames > 0);
stm->frames_read += input_frames;
ALOGV(
"(%p) input: buffers %u, size %u, channels %u, rendered frames %d, "
"total frames %lu.",
stm, (
unsigned int)input_buffer_list.mNumberBuffers,
(
unsigned int)input_buffer_list.mBuffers[0].mDataByteSize,
(
unsigned int)input_buffer_list.mBuffers[0].mNumberChannels,
(
unsigned int)input_frames,
stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame);
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);
assert(stm->input_unit != NULL);
assert(AU_IN_BUS == bus);
if (stm->shutdown) {
ALOG(
"(%p) input shutdown", stm);
return noErr;
}
if (stm->draining) {
OSStatus r = AudioOutputUnitStop(stm->input_unit);
assert(r == 0);
// Only fire state callback in input-only stream. For duplex stream,
// the state callback will be fired in output callback.
if (stm->output_unit == NULL) {
stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_DRAINED);
}
return noErr;
}
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) {
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;
long outframes = cubeb_resampler_fill(stm->resampler.get(),
stm->input_linear_buffer->data(),
&total_input_frames, NULL, 0);
if (outframes < 0) {
stm->shutdown =
true;
OSStatus r = AudioOutputUnitStop(stm->input_unit);
assert(r == 0);
stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
return noErr;
}
stm->draining = outframes < total_input_frames;
// Reset input buffer
stm->input_linear_buffer->clear();
return noErr;
}
static void
audiounit_mix_output_buffer(cubeb_stream * stm, size_t output_frames,
void * input_buffer, size_t input_buffer_size,
void * output_buffer, size_t output_buffer_size)
{
assert(input_buffer_size >=
cubeb_sample_size(stm->output_stream_params.format) *
stm->output_stream_params.channels * output_frames);
assert(output_buffer_size >= stm->output_desc.mBytesPerFrame * output_frames);
int r = cubeb_mixer_mix(stm->mixer.get(), output_frames, input_buffer,
input_buffer_size, output_buffer, output_buffer_size);
if (r != 0) {
LOG(
"Remix error = %d", r);
}
}
// Return how many input frames (sampled at input_hw_rate) are needed to provide
// output_frames (sampled at output_stream_params.rate)
static int64_t
minimum_resampling_input_frames(cubeb_stream * stm, uint32_t output_frames)
{
if (stm->input_hw_rate == stm->output_stream_params.rate) {
// Fast path.
return output_frames;
}
return ceil(stm->input_hw_rate * output_frames /
stm->output_stream_params.rate);
}
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);
uint64_t now = ConvertHostTimeToNanos(mach_absolute_time());
uint64_t audio_output_time = ConvertHostTimeToNanos(tstamp->mHostTime);
uint64_t output_latency_ns = audio_output_time - now;
const int ns2s = 1e9;
// The total output latency is the timestamp difference + the stream latency +
// the hardware latency.
stm->total_output_latency_frames =
output_latency_ns * stm->output_hw_rate / ns2s +
stm->current_latency_frames;
ALOGV(
"(%p) output: buffers %u, size %u, channels %u, frames %u, total input "
"frames %lu.",
stm, (
unsigned int)outBufferList->mNumberBuffers,
(
unsigned int)outBufferList->mBuffers[0].mDataByteSize,
(
unsigned int)outBufferList->mBuffers[0].mNumberChannels,
(
unsigned int)output_frames,
has_input(stm) ? stm->input_linear_buffer->length() /
stm->input_desc.mChannelsPerFrame
: 0);
long input_frames = 0;
void *output_buffer = NULL, *input_buffer = NULL;
if (stm->shutdown) {
ALOG(
"(%p) output shutdown.", stm);
audiounit_make_silent(&outBufferList->mBuffers[0]);
return noErr;
}
if (stm->draining) {
OSStatus r = AudioOutputUnitStop(stm->output_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. */
if (stm->mixer) {
// If remixing needs to occur, we can't directly work in our final
// destination buffer as data may be overwritten or too small to start with.
size_t size_needed = output_frames * stm->output_stream_params.channels *
cubeb_sample_size(stm->output_stream_params.format);
if (stm->temp_buffer_size < size_needed) {
stm->temp_buffer.reset(
new uint8_t[size_needed]);
stm->temp_buffer_size = size_needed;
}
output_buffer = stm->temp_buffer.get();
}
else {
output_buffer = outBufferList->mBuffers[0].mData;
}
stm->frames_written += output_frames;
/* If Full duplex get also input buffer */
if (stm->input_unit != NULL) {
/* 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. */
uint32_t input_frames_needed =
minimum_resampling_input_frames(stm, stm->frames_written);
long missing_frames = input_frames_needed - stm->frames_read;
if (missing_frames > 0) {
stm->input_linear_buffer->push_silence(missing_frames *
stm->input_desc.mChannelsPerFrame);
stm->frames_read = input_frames_needed;
ALOG(
"(%p) %s pushed %ld frames of input silence.", stm,
stm->frames_read == 0 ?
"Input hasn't started,"
: stm->switching_device ?
"Device switching,"
:
"Drop out,",
missing_frames);
}
input_buffer = stm->input_linear_buffer->data();
// Number of input frames in the buffer. It will change to actually used
// frames inside fill
input_frames =
stm->input_linear_buffer->length() / stm->input_desc.mChannelsPerFrame;
}
/* Call user callback through resampler. */
long outframes = cubeb_resampler_fill(stm->resampler.get(), input_buffer,
input_buffer ? &input_frames : NULL,
output_buffer, output_frames);
if (input_buffer) {
// Pop from the buffer the frames used by the the resampler.
stm->input_linear_buffer->pop(input_frames *
stm->input_desc.mChannelsPerFrame);
}
if (outframes < 0 || outframes > output_frames) {
stm->shutdown =
true;
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_ERROR);
audiounit_make_silent(&outBufferList->mBuffers[0]);
return noErr;
}
stm->draining = (UInt32)outframes < output_frames;
stm->frames_played = stm->frames_queued;
stm->frames_queued += outframes;
/* Post process output samples. */
if (stm->draining) {
/* Clear missing frames (silence) */
size_t channels = stm->output_stream_params.channels;
size_t missing_samples = (output_frames - outframes) * channels;
size_t size_sample = cubeb_sample_size(stm->output_stream_params.format);
/* number of bytes that have been filled with valid audio by the callback.
*/
size_t audio_byte_count = outframes * channels * size_sample;
PodZero((uint8_t *)output_buffer + audio_byte_count,
missing_samples * size_sample);
}
/* Mixing */
if (stm->mixer) {
audiounit_mix_output_buffer(stm, output_frames, output_buffer,
stm->temp_buffer_size,
outBufferList->mBuffers[0].mData,
outBufferList->mBuffers[0].mDataByteSize);
}
return noErr;
}
extern "C" {
int
audiounit_init(cubeb ** context,
char const *
/* context_name */)
{
#if !TARGET_OS_IPHONE
cubeb_set_coreaudio_notification_runloop();
#endif
*context =
new cubeb;
return CUBEB_OK;
}
}
static char const *
audiounit_get_backend_id(cubeb *
/* ctx */)
{
return "audiounit";
}
static int
audiounit_stream_get_volume(cubeb_stream * stm,
float * volume);
static int
audiounit_stream_set_volume(cubeb_stream * stm,
float volume);
#if !TARGET_OS_IPHONE
static int
audiounit_set_device_info(cubeb_stream * stm, AudioDeviceID id, io_side side)
{
assert(stm);
device_info * info = nullptr;
cubeb_device_type type = CUBEB_DEVICE_TYPE_UNKNOWN;
if (side == io_side::INPUT) {
info = &stm->input_device;
type = CUBEB_DEVICE_TYPE_INPUT;
}
else if (side == io_side::OUTPUT) {
info = &stm->output_device;
type = CUBEB_DEVICE_TYPE_OUTPUT;
}
memset(info, 0,
sizeof(device_info));
info->id = id;
if (side == io_side::INPUT) {
info->flags |= DEV_INPUT;
}
else if (side == io_side::OUTPUT) {
info->flags |= DEV_OUTPUT;
}
AudioDeviceID default_device_id = audiounit_get_default_device_id(type);
if (default_device_id == kAudioObjectUnknown) {
return CUBEB_ERROR;
}
if (id == kAudioObjectUnknown) {
info->id = default_device_id;
info->flags |= DEV_SELECTED_DEFAULT;
}
if (info->id == default_device_id) {
info->flags |= DEV_SYSTEM_DEFAULT;
}
assert(info->id);
assert(info->flags & DEV_INPUT && !(info->flags & DEV_OUTPUT) ||
!(info->flags & DEV_INPUT) && info->flags & DEV_OUTPUT);
return CUBEB_OK;
}
#endif
static int
audiounit_reinit_stream(cubeb_stream * stm, device_flags_value flags)
{
auto_lock context_lock(stm->context->mutex);
assert((flags & DEV_INPUT && stm->input_unit) ||
(flags & DEV_OUTPUT && stm->output_unit));
if (!stm->shutdown) {
audiounit_stream_stop_internal(stm);
}
int r;
#if !TARGET_OS_IPHONE
r = audiounit_uninstall_device_changed_callback(stm);
if (r != CUBEB_OK) {
LOG(
"(%p) Could not uninstall all device change listeners.", stm);
}
#endif
{
auto_lock lock(stm->mutex);
float volume = 0.0;
int vol_rv = CUBEB_ERROR;
if (stm->output_unit) {
vol_rv = audiounit_stream_get_volume(stm, &volume);
}
audiounit_close_stream(stm);
#if !TARGET_OS_IPHONE
/* Reinit occurs in one of the following case:
* - When the device is not alive any more
* - When the default system device change.
* - The bluetooth device changed from A2DP to/from HFP/HSP profile
* We first attempt to re-use the same device id, should that fail we will
* default to the (potentially new) default device. */
AudioDeviceID input_device =
flags & DEV_INPUT ? stm->input_device.id : kAudioObjectUnknown;
if (flags & DEV_INPUT) {
r = audiounit_set_device_info(stm, input_device, io_side::INPUT);
if (r != CUBEB_OK) {
LOG(
"(%p) Set input device info failed. This can happen when last "
"media device is unplugged",
stm);
return CUBEB_ERROR;
}
}
/* Always use the default output on reinit. This is not correct in every
* case but it is sufficient for Firefox and prevent reinit from reporting
* failures. It will change soon when reinit mechanism will be updated. */
r = audiounit_set_device_info(stm, kAudioObjectUnknown, io_side::OUTPUT);
if (r != CUBEB_OK) {
LOG(
"(%p) Set output device info failed. This can happen when last media "
"device is unplugged",
stm);
return CUBEB_ERROR;
}
#endif
if (audiounit_setup_stream(stm) != CUBEB_OK) {
LOG(
"(%p) Stream reinit failed.", stm);
#if !TARGET_OS_IPHONE
if (flags & DEV_INPUT && input_device != kAudioObjectUnknown) {
// Attempt to re-use the same device-id failed, so attempt again with
// default input device.
audiounit_close_stream(stm);
if (audiounit_set_device_info(stm, kAudioObjectUnknown,
io_side::INPUT) != CUBEB_OK ||
audiounit_setup_stream(stm) != CUBEB_OK) {
LOG(
"(%p) Second stream reinit failed.", stm);
return CUBEB_ERROR;
}
}
#endif
}
if (vol_rv == CUBEB_OK) {
audiounit_stream_set_volume(stm, volume);
}
// If the stream was running, start it again.
if (!stm->shutdown) {
r = audiounit_stream_start_internal(stm);
if (r != CUBEB_OK) {
return CUBEB_ERROR;
}
}
}
return CUBEB_OK;
}
static void
audiounit_reinit_stream_async(cubeb_stream * stm, device_flags_value flags)
{
if (std::atomic_exchange(&stm->reinit_pending,
true)) {
// A reinit task is already pending, nothing more to do.
ALOG(
"(%p) re-init stream task already pending, cancelling request", stm);
return;
}
// 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 (stm->destroy_pending) {
ALOG(
"(%p) stream pending destroy, cancelling reinit task", stm);
return;
}
if (audiounit_reinit_stream(stm, flags) != CUBEB_OK) {
#if !TARGET_OS_IPHONE
if (audiounit_uninstall_system_changed_callback(stm) != CUBEB_OK) {
LOG(
"(%p) Could not uninstall system changed callback", stm);
}
#endif
stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_ERROR);
LOG(
"(%p) Could not reopen the stream after switching.", stm);
}
stm->switching_device =
false;
stm->reinit_pending =
false;
});
}
#if !TARGET_OS_IPHONE
static char const *
event_addr_to_string(AudioObjectPropertySelector selector)
{
switch (selector) {
case kAudioHardwarePropertyDefaultOutputDevice:
return "kAudioHardwarePropertyDefaultOutputDevice";
case kAudioHardwarePropertyDefaultInputDevice:
return "kAudioHardwarePropertyDefaultInputDevice";
case kAudioDevicePropertyDeviceIsAlive:
return "kAudioDevicePropertyDeviceIsAlive";
case kAudioDevicePropertyDataSource:
return "kAudioDevicePropertyDataSource";
default:
return "Unknown";
}
}
static OSStatus
audiounit_property_listener_callback(
AudioObjectID id, UInt32 address_count,
const AudioObjectPropertyAddress * addresses,
void * user)
{
cubeb_stream * stm = (cubeb_stream *)user;
if (stm->switching_device) {
LOG(
"Switching is already taking place. Skip Event %s for id=%d",
event_addr_to_string(addresses[0].mSelector), id);
return noErr;
}
stm->switching_device =
true;
LOG(
"(%p) Audio device changed, %u events.", stm,
(
unsigned int)address_count);
for (UInt32 i = 0; i < address_count; i++) {
switch (addresses[i].mSelector) {
case kAudioHardwarePropertyDefaultOutputDevice: {
LOG(
"Event[%u] - mSelector == kAudioHardwarePropertyDefaultOutputDevice "
"for id=%d",
(
unsigned int)i, id);
}
break;
case kAudioHardwarePropertyDefaultInputDevice: {
LOG(
"Event[%u] - mSelector == kAudioHardwarePropertyDefaultInputDevice "
"for id=%d",
(
unsigned int)i, id);
}
break;
case kAudioDevicePropertyDeviceIsAlive: {
LOG(
"Event[%u] - mSelector == kAudioDevicePropertyDeviceIsAlive for "
"id=%d",
(
unsigned int)i, id);
// If this is the default input device ignore the event,
// kAudioHardwarePropertyDefaultInputDevice will take care of the switch
if (stm->input_device.flags & DEV_SYSTEM_DEFAULT) {
LOG(
"It's the default input device, ignore the event");
stm->switching_device =
false;
return noErr;
}
}
break;
case kAudioDevicePropertyDataSource: {
LOG(
"Event[%u] - mSelector == kAudioDevicePropertyDataSource for id=%d",
(
unsigned int)i, id);
}
break;
default:
LOG(
"Event[%u] - mSelector == Unexpected Event id %d, return",
(
unsigned int)i, addresses[i].mSelector);
stm->switching_device =
false;
return noErr;
}
}
// Allow restart to choose the new default
device_flags_value switch_side = DEV_UNKNOWN;
if (has_input(stm)) {
switch_side |= DEV_INPUT;
}
if (has_output(stm)) {
switch_side |= DEV_OUTPUT;
}
for (UInt32 i = 0; i < address_count; i++) {
switch (addresses[i].mSelector) {
case kAudioHardwarePropertyDefaultOutputDevice:
case kAudioHardwarePropertyDefaultInputDevice:
case kAudioDevicePropertyDeviceIsAlive:
/* fall through */
case kAudioDevicePropertyDataSource: {
auto_lock dev_cb_lock(stm->device_changed_callback_lock);
if (stm->device_changed_callback) {
stm->device_changed_callback(stm->user_ptr);
}
break;
}
}
}
audiounit_reinit_stream_async(stm, switch_side);
return noErr;
}
OSStatus
audiounit_add_listener(
const property_listener * listener)
{
assert(listener);
return AudioObjectAddPropertyListener(listener->device_id,
listener->property_address,
listener->callback, listener->stream);
}
OSStatus
audiounit_remove_listener(
const property_listener * listener)
{
assert(listener);
return AudioObjectRemovePropertyListener(
listener->device_id, listener->property_address, listener->callback,
listener->stream);
}
static int
audiounit_install_device_changed_callback(cubeb_stream * stm)
{
OSStatus rv;
int r = CUBEB_OK;
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. */
stm->output_source_listener.reset(
new property_listener(
stm->output_device.id, &OUTPUT_DATA_SOURCE_PROPERTY_ADDRESS,
&audiounit_property_listener_callback, stm));
rv = audiounit_add_listener(stm->output_source_listener.get());
if (rv != noErr) {
stm->output_source_listener.reset();
LOG(
"AudioObjectAddPropertyListener/output/"
"kAudioDevicePropertyDataSource rv=%d, device id=%d",
rv, stm->output_device.id);
r = CUBEB_ERROR;
}
}
if (stm->input_unit) {
/* This event will notify us when the data source on the input device
* changes. */
stm->input_source_listener.reset(
new property_listener(
stm->input_device.id, &INPUT_DATA_SOURCE_PROPERTY_ADDRESS,
&audiounit_property_listener_callback, stm));
rv = audiounit_add_listener(stm->input_source_listener.get());
if (rv != noErr) {
stm->input_source_listener.reset();
LOG(
"AudioObjectAddPropertyListener/input/kAudioDevicePropertyDataSource "
"rv=%d, device id=%d",
rv, stm->input_device.id);
r = CUBEB_ERROR;
}
/* Event to notify when the input is going away. */
stm->input_alive_listener.reset(
new property_listener(
stm->input_device.id, &DEVICE_IS_ALIVE_PROPERTY_ADDRESS,
&audiounit_property_listener_callback, stm));
rv = audiounit_add_listener(stm->input_alive_listener.get());
if (rv != noErr) {
stm->input_alive_listener.reset();
LOG(
"AudioObjectAddPropertyListener/input/"
"kAudioDevicePropertyDeviceIsAlive rv=%d, device id =%d",
rv, stm->input_device.id);
r = CUBEB_ERROR;
}
}
return r;
}
#if !TARGET_OS_IPHONE
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. */
stm->default_output_listener.reset(
new property_listener(
kAudioObjectSystemObject, &DEFAULT_OUTPUT_DEVICE_PROPERTY_ADDRESS,
&audiounit_property_listener_callback, stm));
r = audiounit_add_listener(stm->default_output_listener.get());
if (r != noErr) {
stm->default_output_listener.reset();
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. */
stm->default_input_listener.reset(
new property_listener(
kAudioObjectSystemObject, &DEFAULT_INPUT_DEVICE_PROPERTY_ADDRESS,
&audiounit_property_listener_callback, stm));
r = audiounit_add_listener(stm->default_input_listener.get());
if (r != noErr) {
stm->default_input_listener.reset();
LOG(
"AudioObjectAddPropertyListener/input/"
"kAudioHardwarePropertyDefaultInputDevice rv=%d",
r);
return CUBEB_ERROR;
}
}
return CUBEB_OK;
}
#endif
static int
audiounit_uninstall_device_changed_callback(cubeb_stream * stm)
{
OSStatus rv;
// Failing to uninstall listeners is not a fatal error.
int r = CUBEB_OK;
if (stm->output_source_listener) {
rv = audiounit_remove_listener(stm->output_source_listener.get());
if (rv != noErr) {
LOG(
"AudioObjectRemovePropertyListener/output/"
"kAudioDevicePropertyDataSource rv=%d, device id=%d",
rv, stm->output_device.id);
r = CUBEB_ERROR;
}
stm->output_source_listener.reset();
}
if (stm->input_source_listener) {
rv = audiounit_remove_listener(stm->input_source_listener.get());
if (rv != noErr) {
LOG(
"AudioObjectRemovePropertyListener/input/"
"kAudioDevicePropertyDataSource rv=%d, device id=%d",
rv, stm->input_device.id);
r = CUBEB_ERROR;
}
stm->input_source_listener.reset();
}
if (stm->input_alive_listener) {
rv = audiounit_remove_listener(stm->input_alive_listener.get());
if (rv != noErr) {
LOG(
"AudioObjectRemovePropertyListener/input/"
"kAudioDevicePropertyDeviceIsAlive rv=%d, device id=%d",
rv, stm->input_device.id);
r = CUBEB_ERROR;
}
stm->input_alive_listener.reset();
}
return r;
}
static int
audiounit_uninstall_system_changed_callback(cubeb_stream * stm)
{
OSStatus r;
if (stm->default_output_listener) {
r = audiounit_remove_listener(stm->default_output_listener.get());
if (r != noErr) {
return CUBEB_ERROR;
}
stm->default_output_listener.reset();
}
if (stm->default_input_listener) {
r = audiounit_remove_listener(stm->default_input_listener.get());
if (r != noErr) {
return CUBEB_ERROR;
}
stm->default_input_listener.reset();
}
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,
kAudioObjectPropertyElementMain};
output_device_id = audiounit_get_default_device_id(CUBEB_DEVICE_TYPE_OUTPUT);
if (output_device_id == kAudioObjectUnknown) {
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) {
LOG(
"AudioObjectGetPropertyData/buffer size range rv=%d", r);
return CUBEB_ERROR;
}
return CUBEB_OK;
}
static AudioObjectID
audiounit_get_default_device_id(cubeb_device_type type)
{
const AudioObjectPropertyAddress * adr;
if (type == CUBEB_DEVICE_TYPE_OUTPUT) {
adr = &DEFAULT_OUTPUT_DEVICE_PROPERTY_ADDRESS;
}
else if (type == CUBEB_DEVICE_TYPE_INPUT) {
adr = &DEFAULT_INPUT_DEVICE_PROPERTY_ADDRESS;
}
else {
return kAudioObjectUnknown;
}
AudioDeviceID devid;
UInt32 size =
sizeof(AudioDeviceID);
if (AudioObjectGetPropertyData(kAudioObjectSystemObject, adr, 0, NULL, &size,
&devid) != noErr) {
return kAudioObjectUnknown;
}
return devid;
}
#endif /* !TARGET_OS_IPHONE */
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,
kAudioObjectPropertyElementMain};
assert(ctx && max_channels);
output_device_id = audiounit_get_default_device_id(CUBEB_DEVICE_TYPE_OUTPUT);
if (output_device_id == kAudioObjectUnknown) {
return CUBEB_ERROR;
}
size =
sizeof(stream_format);
r = AudioObjectGetPropertyData(output_device_id, &stream_format_address, 0,
NULL, &size, &stream_format);
if (r != noErr) {
LOG(
"AudioObjectPropertyAddress/StreamFormat rv=%d", 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 =
max<uint32_t>(latency_range.mMinimum, SAFE_MIN_LATENCY_FRAMES);
return CUBEB_OK;
#endif
}
static int
audiounit_get_preferred_sample_rate(cubeb *
/* ctx */, uint32_t * rate)
{
#if TARGET_OS_IPHONE
*rate = 44100;
return CUBEB_OK;
#else
UInt32 size;
OSStatus r;
Float64 fsamplerate;
AudioDeviceID output_device_id;
AudioObjectPropertyAddress samplerate_address = {
kAudioDevicePropertyNominalSampleRate, kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMain};
output_device_id = audiounit_get_default_device_id(CUBEB_DEVICE_TYPE_OUTPUT);
if (output_device_id == kAudioObjectUnknown) {
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);
return CUBEB_OK;
#endif
}
static cubeb_channel_layout
audiounit_convert_channel_layout(AudioChannelLayout * layout)
{
// When having one or two channel, force mono or stereo. Some devices (namely,
// Bose QC35, mark 1 and 2), expose a single channel mapped to the right for
// some reason.
if (layout->mNumberChannelDescriptions == 1) {
return CUBEB_LAYOUT_MONO;
}
else if (layout->mNumberChannelDescriptions == 2) {
return CUBEB_LAYOUT_STEREO;
}
if (layout->mChannelLayoutTag !=
kAudioChannelLayoutTag_UseChannelDescriptions) {
// kAudioChannelLayoutTag_UseChannelBitmap
// kAudioChannelLayoutTag_Mono
// kAudioChannelLayoutTag_Stereo
// ....
LOG(
"Only handle UseChannelDescriptions for now.\n");
return CUBEB_LAYOUT_UNDEFINED;
}
cubeb_channel_layout cl = 0;
for (UInt32 i = 0; i < layout->mNumberChannelDescriptions; ++i) {
cubeb_channel cc = channel_label_to_cubeb_channel(
layout->mChannelDescriptions[i].mChannelLabel);
if (cc == CHANNEL_UNKNOWN) {
return CUBEB_LAYOUT_UNDEFINED;
}
cl |= cc;
}
return cl;
}
static cubeb_channel_layout
audiounit_get_preferred_channel_layout(AudioUnit output_unit)
{
#if TARGET_OS_IPHONE
return CUBEB_LAYOUT_STEREO;
#else
OSStatus rv = noErr;
UInt32 size = 0;
rv = AudioUnitGetPropertyInfo(
output_unit, kAudioDevicePropertyPreferredChannelLayout,
kAudioUnitScope_Output, AU_OUT_BUS, &size, nullptr);
if (rv != noErr) {
LOG(
"AudioUnitGetPropertyInfo/kAudioDevicePropertyPreferredChannelLayout "
"rv=%d",
rv);
return CUBEB_LAYOUT_UNDEFINED;
}
assert(size > 0);
auto layout = make_sized_audio_channel_layout(size);
rv = AudioUnitGetProperty(
output_unit, kAudioDevicePropertyPreferredChannelLayout,
kAudioUnitScope_Output, AU_OUT_BUS, layout.get(), &size);
if (rv != noErr) {
LOG(
"AudioUnitGetProperty/kAudioDevicePropertyPreferredChannelLayout rv=%d",
rv);
return CUBEB_LAYOUT_UNDEFINED;
}
return audiounit_convert_channel_layout(layout.get());
#endif
}
static cubeb_channel_layout
audiounit_get_current_channel_layout(AudioUnit output_unit)
{
OSStatus rv = noErr;
UInt32 size = 0;
rv = AudioUnitGetPropertyInfo(
output_unit, kAudioUnitProperty_AudioChannelLayout,
kAudioUnitScope_Output, AU_OUT_BUS, &size, nullptr);
if (rv != noErr) {
LOG(
"AudioUnitGetPropertyInfo/kAudioUnitProperty_AudioChannelLayout rv=%d",
rv);
// This property isn't known before macOS 10.12, attempt another method.
return audiounit_get_preferred_channel_layout(output_unit);
}
assert(size > 0);
auto layout = make_sized_audio_channel_layout(size);
rv = AudioUnitGetProperty(output_unit, kAudioUnitProperty_AudioChannelLayout,
kAudioUnitScope_Output, AU_OUT_BUS, layout.get(),
&size);
if (rv != noErr) {
LOG(
"AudioUnitGetProperty/kAudioUnitProperty_AudioChannelLayout rv=%d", rv);
return CUBEB_LAYOUT_UNDEFINED;
}
return audiounit_convert_channel_layout(layout.get());
}
static int
audiounit_create_unit(AudioUnit * unit, device_info * device);
#if !TARGET_OS_IPHONE
static OSStatus
audiounit_remove_device_listener(cubeb * context, cubeb_device_type devtype);
#endif
static void
audiounit_destroy(cubeb * ctx)
{
{
auto_lock lock(ctx->mutex);
// Disabling this assert for bug 1083664 -- we seem to leak a stream
// assert(ctx->active_streams == 0);
if (audiounit_active_streams(ctx) > 0) {
LOG(
"(%p) API misuse, %d streams active when context destroyed!", ctx,
audiounit_active_streams(ctx));
}
// Destroying a cubeb context with device collection callbacks registered
// is misuse of the API, assert then attempt to clean up.
assert(!ctx->input_collection_changed_callback &&
!ctx->input_collection_changed_user_ptr &&
!ctx->output_collection_changed_callback &&
!ctx->output_collection_changed_user_ptr);
#if !TARGET_OS_IPHONE
/* Unregister the callback if necessary. */
if (ctx->input_collection_changed_callback) {
audiounit_remove_device_listener(ctx, CUBEB_DEVICE_TYPE_INPUT);
}
if (ctx->output_collection_changed_callback) {
audiounit_remove_device_listener(ctx, CUBEB_DEVICE_TYPE_OUTPUT);
}
#endif
}
dispatch_release(ctx->serial_queue);
delete 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;
}
void
audiounit_init_mixer(cubeb_stream * stm)
{
// We can't rely on macOS' AudioUnit to properly downmix (or upmix) the audio
// data, it silently drop the channels so we need to remix the
// audio data by ourselves to keep all the information.
stm->mixer.reset(cubeb_mixer_create(
stm->output_stream_params.format, stm->output_stream_params.channels,
stm->output_stream_params.layout, stm->context->channels,
stm->context->layout));
assert(stm->mixer);
}
static int
audiounit_set_channel_layout(AudioUnit unit, io_side side,
cubeb_channel_layout layout)
{
if (side != io_side::OUTPUT) {
return CUBEB_ERROR;
}
if (layout == CUBEB_LAYOUT_UNDEFINED) {
// We leave everything as-is...
return CUBEB_OK;
}
OSStatus r;
uint32_t nb_channels = cubeb_channel_layout_nb_channels(layout);
// We do not use CoreAudio standard layout for lack of documentation on what
// the actual channel orders are. So we set a custom layout.
size_t size = offsetof(AudioChannelLayout, mChannelDescriptions[nb_channels]);
auto au_layout = make_sized_audio_channel_layout(size);
au_layout->mChannelLayoutTag = kAudioChannelLayoutTag_UseChannelDescriptions;
au_layout->mNumberChannelDescriptions = nb_channels;
uint32_t channels = 0;
cubeb_channel_layout channelMap = layout;
for (uint32_t i = 0; channelMap != 0; ++i) {
XASSERT(channels < nb_channels);
uint32_t channel = (channelMap & 1) << i;
if (channel != 0) {
au_layout->mChannelDescriptions[channels].mChannelLabel =
cubeb_channel_to_channel_label(
static_cast<cubeb_channel>(channel));
au_layout->mChannelDescriptions[channels].mChannelFlags =
kAudioChannelFlags_AllOff;
channels++;
}
channelMap = channelMap >> 1;
}
r = AudioUnitSetProperty(unit, kAudioUnitProperty_AudioChannelLayout,
kAudioUnitScope_Input, AU_OUT_BUS, au_layout.get(),
size);
if (r != noErr) {
LOG(
"AudioUnitSetProperty/%s/kAudioUnitProperty_AudioChannelLayout rv=%d",
to_string(side), r);
return CUBEB_ERROR;
}
return CUBEB_OK;
}
void
audiounit_layout_init(cubeb_stream * stm, io_side side)
{
// We currently don't support the input layout setting.
if (side == io_side::INPUT) {
return;
}
stm->context->layout = audiounit_get_current_channel_layout(stm->output_unit);
audiounit_set_channel_layout(stm->output_unit, io_side::OUTPUT,
stm->context->layout);
}
#if !TARGET_OS_IPHONE
static vector<AudioObjectID>
audiounit_get_sub_devices(AudioDeviceID device_id)
{
vector<AudioDeviceID> sub_devices;
AudioObjectPropertyAddress property_address = {
kAudioAggregateDevicePropertyActiveSubDeviceList,
kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMain};
UInt32 size = 0;
OSStatus rv = AudioObjectGetPropertyDataSize(device_id, &property_address, 0,
nullptr, &size);
if (rv != noErr) {
sub_devices.push_back(device_id);
return sub_devices;
}
uint32_t count =
static_cast<uint32_t>(size /
sizeof(AudioObjectID));
sub_devices.resize(count);
rv = AudioObjectGetPropertyData(device_id, &property_address, 0, nullptr,
&size, sub_devices.data());
if (rv != noErr) {
sub_devices.clear();
sub_devices.push_back(device_id);
}
else {
LOG(
"Found %u sub-devices", count);
}
return sub_devices;
}
static int
audiounit_create_blank_aggregate_device(AudioObjectID * plugin_id,
AudioDeviceID * aggregate_device_id)
{
AudioObjectPropertyAddress address_plugin_bundle_id = {
kAudioHardwarePropertyPlugInForBundleID, kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMain};
UInt32 size = 0;
OSStatus r = AudioObjectGetPropertyDataSize(
kAudioObjectSystemObject, &address_plugin_bundle_id, 0, NULL, &size);
if (r != noErr) {
LOG(
"AudioObjectGetPropertyDataSize/"
"kAudioHardwarePropertyPlugInForBundleID, rv=%d",
r);
return CUBEB_ERROR;
}
AudioValueTranslation translation_value;
CFStringRef in_bundle_ref = CFSTR(
"com.apple.audio.CoreAudio");
translation_value.mInputData = &in_bundle_ref;
translation_value.mInputDataSize =
sizeof(in_bundle_ref);
translation_value.mOutputData = plugin_id;
translation_value.mOutputDataSize =
sizeof(*plugin_id);
r = AudioObjectGetPropertyData(kAudioObjectSystemObject,
&address_plugin_bundle_id, 0, nullptr, &size,
&translation_value);
if (r != noErr) {
LOG(
"AudioObjectGetPropertyData/kAudioHardwarePropertyPlugInForBundleID, "
"rv=%d",
r);
return CUBEB_ERROR;
}
AudioObjectPropertyAddress create_aggregate_device_address = {
kAudioPlugInCreateAggregateDevice, kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMain};
r = AudioObjectGetPropertyDataSize(
*plugin_id, &create_aggregate_device_address, 0, nullptr, &size);
if (r != noErr) {
LOG(
"AudioObjectGetPropertyDataSize/kAudioPlugInCreateAggregateDevice, "
"rv=%d",
r);
return CUBEB_ERROR;
}
CFMutableDictionaryRef aggregate_device_dict = CFDictionaryCreateMutable(
kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
struct timeval timestamp;
gettimeofday(×tamp, NULL);
long long int time_id = timestamp.tv_sec * 1000000LL + timestamp.tv_usec;
CFStringRef aggregate_device_name = CFStringCreateWithFormat(
NULL, NULL, CFSTR(
"%s_%llx"), PRIVATE_AGGREGATE_DEVICE_NAME, time_id);
CFDictionaryAddValue(aggregate_device_dict,
CFSTR(kAudioAggregateDeviceNameKey),
aggregate_device_name);
CFRelease(aggregate_device_name);
CFStringRef aggregate_device_UID =
CFStringCreateWithFormat(NULL, NULL, CFSTR(
"org.mozilla.%s_%llx"),
PRIVATE_AGGREGATE_DEVICE_NAME, time_id);
CFDictionaryAddValue(aggregate_device_dict,
CFSTR(kAudioAggregateDeviceUIDKey),
aggregate_device_UID);
CFRelease(aggregate_device_UID);
int private_value = 1;
CFNumberRef aggregate_device_private_key =
CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &private_value);
CFDictionaryAddValue(aggregate_device_dict,
CFSTR(kAudioAggregateDeviceIsPrivateKey),
aggregate_device_private_key);
CFRelease(aggregate_device_private_key);
int stacked_value = 0;
CFNumberRef aggregate_device_stacked_key =
CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &stacked_value);
CFDictionaryAddValue(aggregate_device_dict,
CFSTR(kAudioAggregateDeviceIsStackedKey),
aggregate_device_stacked_key);
CFRelease(aggregate_device_stacked_key);
r = AudioObjectGetPropertyData(*plugin_id, &create_aggregate_device_address,
sizeof(aggregate_device_dict),
&aggregate_device_dict, &size,
aggregate_device_id);
CFRelease(aggregate_device_dict);
if (r != noErr) {
LOG(
"AudioObjectGetPropertyData/kAudioPlugInCreateAggregateDevice, rv=%d",
r);
return CUBEB_ERROR;
}
LOG(
"New aggregate device %u", *aggregate_device_id);
return CUBEB_OK;
}
// The returned CFStringRef object needs to be released (via CFRelease)
// if it's not NULL, since the reference count of the returned CFStringRef
// object is increased.
static CFStringRef
get_device_name(AudioDeviceID id)
{
UInt32 size =
sizeof(CFStringRef);
CFStringRef UIname = nullptr;
AudioObjectPropertyAddress address_uuid = {kAudioDevicePropertyDeviceUID,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMain};
OSStatus err =
AudioObjectGetPropertyData(id, &address_uuid, 0, nullptr, &size, &UIname);
return (err == noErr) ? UIname : NULL;
}
static int
audiounit_set_aggregate_sub_device_list(AudioDeviceID aggregate_device_id,
AudioDeviceID input_device_id,
AudioDeviceID output_device_id)
{
LOG(
"Add devices input %u and output %u into aggregate device %u",
input_device_id, output_device_id, aggregate_device_id);
const vector<AudioDeviceID> output_sub_devices =
audiounit_get_sub_devices(output_device_id);
const vector<AudioDeviceID> input_sub_devices =
audiounit_get_sub_devices(input_device_id);
CFMutableArrayRef aggregate_sub_devices_array =
CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
/* The order of the items in the array is significant and is used to determine
the order of the streams of the AudioAggregateDevice. */
for (UInt32 i = 0; i < output_sub_devices.size(); i++) {
CFStringRef ref = get_device_name(output_sub_devices[i]);
if (ref == NULL) {
CFRelease(aggregate_sub_devices_array);
return CUBEB_ERROR;
}
CFArrayAppendValue(aggregate_sub_devices_array, ref);
CFRelease(ref);
}
for (UInt32 i = 0; i < input_sub_devices.size(); i++) {
CFStringRef ref = get_device_name(input_sub_devices[i]);
if (ref == NULL) {
CFRelease(aggregate_sub_devices_array);
return CUBEB_ERROR;
}
CFArrayAppendValue(aggregate_sub_devices_array, ref);
CFRelease(ref);
}
AudioObjectPropertyAddress aggregate_sub_device_list = {
kAudioAggregateDevicePropertyFullSubDeviceList,
kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMain};
UInt32 size =
sizeof(CFMutableArrayRef);
OSStatus rv = AudioObjectSetPropertyData(
aggregate_device_id, &aggregate_sub_device_list, 0, nullptr, size,
&aggregate_sub_devices_array);
CFRelease(aggregate_sub_devices_array);
if (rv != noErr) {
LOG(
"AudioObjectSetPropertyData/"
"kAudioAggregateDevicePropertyFullSubDeviceList, rv=%d",
rv);
return CUBEB_ERROR;
}
return CUBEB_OK;
}
static int
audiounit_set_master_aggregate_device(
const AudioDeviceID aggregate_device_id)
{
assert(aggregate_device_id != kAudioObjectUnknown);
AudioObjectPropertyAddress master_aggregate_sub_device = {
kAudioAggregateDevicePropertyMasterSubDevice,
kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMain};
// Master become the 1st output sub device
AudioDeviceID output_device_id =
audiounit_get_default_device_id(CUBEB_DEVICE_TYPE_OUTPUT);
const vector<AudioDeviceID> output_sub_devices =
audiounit_get_sub_devices(output_device_id);
CFStringRef master_sub_device = get_device_name(output_sub_devices[0]);
UInt32 size =
sizeof(CFStringRef);
OSStatus rv = AudioObjectSetPropertyData(aggregate_device_id,
&master_aggregate_sub_device, 0,
NULL, size, &master_sub_device);
if (master_sub_device) {
CFRelease(master_sub_device);
}
if (rv != noErr) {
LOG(
"AudioObjectSetPropertyData/"
"kAudioAggregateDevicePropertyMasterSubDevice, rv=%d",
rv);
return CUBEB_ERROR;
}
return CUBEB_OK;
}
static int
audiounit_activate_clock_drift_compensation(
const AudioDeviceID aggregate_device_id)
{
assert(aggregate_device_id != kAudioObjectUnknown);
AudioObjectPropertyAddress address_owned = {
kAudioObjectPropertyOwnedObjects, kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMain};
UInt32 qualifier_data_size =
sizeof(AudioObjectID);
AudioClassID class_id = kAudioSubDeviceClassID;
void * qualifier_data = &class_id;
UInt32 size = 0;
OSStatus rv = AudioObjectGetPropertyDataSize(
aggregate_device_id, &address_owned, qualifier_data_size, qualifier_data,
&size);
if (rv != noErr) {
LOG(
"AudioObjectGetPropertyDataSize/kAudioObjectPropertyOwnedObjects, "
"rv=%d",
rv);
return CUBEB_ERROR;
}
UInt32 subdevices_num = 0;
subdevices_num = size /
sizeof(AudioObjectID);
AudioObjectID sub_devices[subdevices_num];
size =
sizeof(sub_devices);
rv = AudioObjectGetPropertyData(aggregate_device_id, &address_owned,
qualifier_data_size, qualifier_data, &size,
sub_devices);
if (rv != noErr) {
LOG(
"AudioObjectGetPropertyData/kAudioObjectPropertyOwnedObjects, rv=%d",
rv);
return CUBEB_ERROR;
}
AudioObjectPropertyAddress address_drift = {
kAudioSubDevicePropertyDriftCompensation, kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMain};
// Start from the second device since the first is the master clock
for (UInt32 i = 1; i < subdevices_num; ++i) {
UInt32 drift_compensation_value = 1;
rv = AudioObjectSetPropertyData(sub_devices[i], &address_drift, 0, nullptr,
sizeof(UInt32), &drift_compensation_value);
if (rv != noErr) {
LOG(
"AudioObjectSetPropertyData/"
"kAudioSubDevicePropertyDriftCompensation, rv=%d",
rv);
return CUBEB_OK;
}
}
return CUBEB_OK;
}
static int
audiounit_destroy_aggregate_device(AudioObjectID plugin_id,
AudioDeviceID * aggregate_device_id);
static void
audiounit_get_available_samplerate(AudioObjectID devid,
AudioObjectPropertyScope scope,
uint32_t * min, uint32_t * max,
uint32_t * def);
static int
audiounit_create_device_from_hwdev(cubeb_device_info * dev_info,
AudioObjectID devid, cubeb_device_type type);
static void
audiounit_device_destroy(cubeb_device_info * device);
static void
audiounit_workaround_for_airpod(cubeb_stream * stm)
{
cubeb_device_info input_device_info;
audiounit_create_device_from_hwdev(&input_device_info, stm->input_device.id,
CUBEB_DEVICE_TYPE_INPUT);
cubeb_device_info output_device_info;
audiounit_create_device_from_hwdev(&output_device_info, stm->output_device.id,
CUBEB_DEVICE_TYPE_OUTPUT);
std::string input_name_str(input_device_info.friendly_name);
std::string output_name_str(output_device_info.friendly_name);
if (input_name_str.find(
"AirPods") != std::string::npos &&
output_name_str.find(
"AirPods") != std::string::npos) {
uint32_t input_min_rate = 0;
uint32_t input_max_rate = 0;
uint32_t input_nominal_rate = 0;
audiounit_get_available_samplerate(
stm->input_device.id, kAudioObjectPropertyScopeGlobal, &input_min_rate,
&input_max_rate, &input_nominal_rate);
LOG(
"(%p) Input device %u, name: %s, min: %u, max: %u, nominal rate: %u",
stm, stm->input_device.id, input_device_info.friendly_name,
--> --------------------
--> maximum size reached
--> --------------------
