coreaudio.cpp File Reference

#include "config_unix.h"
#include "config_win32.h"
#include <AudioUnit/AudioUnit.h>
#include <Availability.h>
#include <chrono>
#include <cinttypes>
#include <climits>
#include <CoreAudio/AudioHardware.h>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <string.h>
#include "audio/audio_playback.h"
#include "audio/playback/coreaudio.h"
#include "audio/types.h"
#include "debug.h"
#include "lib_common.h"
#include "utils/audio_buffer.h"
#include "utils/color_out.h"
#include "utils/macos.h"
#include "utils/ring_buffer.h"

Include dependency graph for coreaudio.cpp:

Go to the source code of this file.

Classes
struct	state_ca_playback

Macros
#define	MOD_NAME   "[CoreAudio play.] "
#define	NO_DATA_STOP_SEC   2

Functions
	ADD_TO_PARAM ("ca-disable-adaptive-buf", "* ca-disable-adaptive-buf\n" " Core Audio - use fixed audio playback buffer instead of an adaptive one\n")
AudioDeviceID	audio_ca_get_device_by_name (const char *name, int dir)
void	audio_ca_get_device_name (AudioDeviceID dev_id, size_t namebuf_len, char *namebuf)
void	audio_ca_probe (struct device_info **available_devices, int *count, int dir)
static bool	audio_play_ca_ctl (void *state, int request, void *data, size_t *len)
static void	audio_play_ca_done (void *state)
static void	audio_play_ca_help ()
static void *	audio_play_ca_init (const char *cfg)
static void	audio_play_ca_probe (struct device_info **available_devices, int *count, void(**deleter)(void *))
static void	audio_play_ca_put_frame (void *state, const struct audio_frame *frame)
static bool	audio_play_ca_reconfigure (void *state, struct audio_desc desc)
static bool	is_requested_direction (AudioObjectPropertyAddress propertyAddress, AudioDeviceID *audioDevice)
	REGISTER_MODULE (coreaudio, &aplay_coreaudio_info, LIBRARY_CLASS_AUDIO_PLAYBACK, AUDIO_PLAYBACK_ABI_VERSION)
static OSStatus	theRenderProc (void *inRefCon, AudioUnitRenderActionFlags *inActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, UInt32 inNumFrames, AudioBufferList *ioData)

Variables
static const struct audio_playback_info	aplay_coreaudio_info
constexpr int	CA_DIR = 1
constexpr int	DEFAULT_BUFLEN_MS = 50

Detailed Description

Author

Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Todo

Remove deprecated instances of ca-disable-adaptive-buf after some transitio period.

Definition in file coreaudio.cpp.

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[CoreAudio play.] "

Definition at line 77 of file coreaudio.cpp.

Referenced by audio_ca_probe(), audio_play_ca_init(), audio_play_ca_reconfigure(), is_requested_direction(), and theRenderProc().

NO_DATA_STOP_SEC

#define NO_DATA_STOP_SEC   2

Definition at line 76 of file coreaudio.cpp.

Referenced by theRenderProc().

Function Documentation

ADD_TO_PARAM()

ADD_TO_PARAM	(	"ca-disable-adaptive-buf"	,
		"* ca-disable-adaptive-buf\n" " Core Audio - use fixed audio playback buffer instead of an adaptive one\n"	)

audio_ca_get_device_by_name()

AudioDeviceID audio_ca_get_device_by_name	(	const char *	name,
		int	dir )

@briew tries to get device id from device name

Parameters

name	name of the device to be looked up
dir	direction -

See also

audio_ca_probe for values; dir is needed only for deafult device names

Definition at line 369 of file coreaudio.cpp.

{
        struct device_info *devices = NULL;
        int count = 0;
        audio_ca_probe(&devices, &count, dir);
        for (int i = 0; i < count; ++i) {
                if (strstr(devices[i].name, name) != NULL) {
                        return atoi(devices[i].dev + 1);
                }
        }
        return UINT_MAX;
}

References audio_ca_probe(), count, device_info::dev, and name.

Referenced by audio_cap_ca_init(), and audio_play_ca_init().

Here is the call graph for this function:

audio_ca_get_device_name()

void audio_ca_get_device_name	(	AudioDeviceID	dev_id,
		size_t	namebuf_len,
		char *	namebuf )

Definition at line 281 of file coreaudio.cpp.

{
        AudioObjectPropertyAddress propertyAddress{};
        propertyAddress.mSelector = kAudioHardwarePropertyDevices;
        propertyAddress.mScope = kAudioObjectPropertyScopeGlobal;
        propertyAddress.mElement = kAudioObjectPropertyElementMain;
        propertyAddress.mSelector = kAudioDevicePropertyDeviceNameCFString;
        CFStringRef deviceName = NULL;
        UInt32 size = sizeof(deviceName);
        if (OSStatus ret = AudioObjectGetPropertyData(dev_id, &propertyAddress, 0, NULL, &size, &deviceName)) {
                log_msg(LOG_LEVEL_WARNING, "[CoreAudio] Cannot get device %" PRIu32 " name: %s\n",
                        dev_id, get_osstatus_str(ret));
                snprintf(namebuf, namebuf_len, "CoreAudio device #%" PRIu32 " (unable to get name)", dev_id);
                return;
        }
        CFStringGetCString(deviceName, namebuf, namebuf_len, kCFStringEncodingMacRoman);
        CFRelease(deviceName);
}

References get_osstatus_str(), kAudioObjectPropertyElementMain, LOG_LEVEL_WARNING, and log_msg().

Referenced by audio_ca_probe(), audio_cap_ca_init(), and audio_play_ca_init().

Here is the call graph for this function:

audio_ca_probe()

void audio_ca_probe	(	struct device_info **	available_devices,
		int *	count,
		int	dir )

@briew probe for available capture/playback devices (direction given by parameter dir)

Parameters

dir	-1 capture, 1 playback

Definition at line 305 of file coreaudio.cpp.

{
        assert(dir == -1 || dir == 1);
        *available_devices =
            (struct device_info *) calloc(1, sizeof(struct device_info));
        snprintf((*available_devices)[0].dev, sizeof(*available_devices)[0].dev,
                 "");
        snprintf((*available_devices)[0].name,
                 sizeof(*available_devices)[0].name, "Default CoreAudio %s",
                 dir == -1 ? "capture" : "playback");
        *count = 1;
 
        int dev_count;
        AudioDeviceID *dev_ids;
        OSStatus ret;
        UInt32 size;
        AudioObjectPropertyAddress propertyAddress;
 
        propertyAddress.mSelector = kAudioHardwarePropertyDevices;
        propertyAddress.mScope = kAudioObjectPropertyScopeGlobal;
        propertyAddress.mElement = kAudioObjectPropertyElementMain;
        ret = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &propertyAddress, 0, NULL, &size);
        if (ret) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot get device list size: %s\n", get_osstatus_str(ret));
                goto error;
        }
        dev_ids = (AudioDeviceID *) malloc(size);
        dev_count = size / sizeof(AudioDeviceID);
        ret = AudioObjectGetPropertyData(kAudioObjectSystemObject, &propertyAddress, 0, NULL, &size, dev_ids);
        if (ret) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot get device list: %s\n", get_osstatus_str(ret));
                goto error;
        }
 
        propertyAddress.mScope = dir == -1 ? kAudioObjectPropertyScopeInput : kAudioObjectPropertyScopeOutput;
        for (int i = 0; i < dev_count; ++i) {
                if (dir != 0 && !is_requested_direction(propertyAddress, &dev_ids[i])) {
                        continue;
                }
 
                (*count)++;
                *available_devices = (struct device_info *) realloc(*available_devices, *count * sizeof(struct device_info));
                memset(&(*available_devices)[*count - 1], 0, sizeof(struct device_info));
 
                audio_ca_get_device_name(dev_ids[i], sizeof (*available_devices)[*count - 1].name,
                                         (char *) (*available_devices)[*count - 1].name);
                snprintf((*available_devices)[*count - 1].dev, sizeof (*available_devices)[*count - 1].dev,
                                ":%" PRIu32, dev_ids[i]);
        }
        free(dev_ids);
 
        return;
 
error:
        LOG(LOG_LEVEL_ERROR) << MOD_NAME "Error obtaining device list.\n";
}

References audio_ca_get_device_name(), count, device_info::dev, get_osstatus_str(), is_requested_direction(), kAudioObjectPropertyElementMain, LOG, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, and name.

Referenced by audio_ca_get_device_by_name(), audio_cap_ca_probe(), and audio_play_ca_probe().

Here is the call graph for this function:

audio_play_ca_ctl()

static bool audio_play_ca_ctl ( void * state, int request, void * data, size_t * len )

static

Definition at line 133 of file coreaudio.cpp.

{
        switch (request) {
        case AUDIO_PLAYBACK_CTL_QUERY_FORMAT:
                if (*len >= sizeof(struct audio_desc)) {
                        struct audio_desc desc;
                        memcpy(&desc, data, sizeof desc);
                        desc.codec = AC_PCM;
                        memcpy(data, &desc, sizeof desc);
                        *len = sizeof desc;
                        return true;
                } else{
                        return false;
                }
        default:
                return false;
        }
}

References AC_PCM, AUDIO_PLAYBACK_CTL_QUERY_FORMAT, desc, and len.

audio_play_ca_done()

static void audio_play_ca_done ( void * state )

static

Definition at line 524 of file coreaudio.cpp.

{
        struct state_ca_playback *s = (struct state_ca_playback *)state;
 
        if (s->initialized) {
                AudioOutputUnitStop(s->auHALComponentInstance);
                AudioUnitUninitialize(s->auHALComponentInstance);
        }
        if (s->buffer_fns) {
                s->buffer_fns->destroy(s->buffer);
        }
        delete s;
}

References state_ca_playback::auHALComponentInstance, state_ca_playback::buffer, state_ca_playback::buffer_fns, audio_buffer_api::destroy, state_ca_playback::initialized, and state.

audio_play_ca_help()

static void audio_play_ca_help ( )

static

Definition at line 388 of file coreaudio.cpp.

{
        cout << "Core Audio playback usage:\n";
        col() << SBOLD(SRED("\t-r coreaudio") << "[:<index>|:<name>] "
                "[--param audio-buffer-len=<len_ms>] [--param audio-disable-adaptive-buffer]") << "\n";
        col() << "where\n\t" << SBOLD("<name>") << " - device name substring (case sensitive)\n\n";
        printf("Available CoreAudio playback devices:\n");
        struct device_info *available_devices;
        int count;
        void (*deleter)(void *);
        audio_play_ca_probe(&available_devices, &count, &deleter);
 
        for (int i = 0; i < count; ++i) {
                color_printf("\t" TBOLD("coreaudio%-4s") ": %s\n", available_devices[i].dev, available_devices[i].name);
        }
        deleter ? deleter(available_devices) : free(available_devices);
}

References audio_play_ca_probe(), color_printf(), count, deleter, device_info::dev, name, SBOLD, SRED, and TBOLD.

Referenced by audio_play_ca_init().

Here is the call graph for this function:

audio_play_ca_init()

static void * audio_play_ca_init ( const char * cfg )

static

Definition at line 407 of file coreaudio.cpp.

{
        OSStatus ret = noErr;
        AudioComponent comp;
        AudioComponentDescription comp_desc;
        AudioDeviceID device;
 
        struct state_ca_playback *s = new struct state_ca_playback();
 
        if (const char *val = get_commandline_param("audio-buffer-len")) {
                s->buf_len_ms = atoi(val);
                if (s->buf_len_ms <= 0 || s->buf_len_ms >= 10000) {
                        LOG(LOG_LEVEL_ERROR) << MOD_NAME "Wrong value \"" <<  val << "\" given to \"audio-buffer-len\", allowed range (0, 10000).\n";
                        goto error;
                }
        }
 
        //There are several different types of Audio Units.
        //Some audio units serve as Outputs, Mixers, or DSP
        //units. See AUComponent.h for listing
        comp_desc.componentType = kAudioUnitType_Output;
 
        //Every Component has a subType, which will give a clearer picture
        //of what this components function will be.
        //comp_desc.componentSubType = kAudioUnitSubType_DefaultOutput;
        comp_desc.componentSubType = kAudioUnitSubType_HALOutput;
 
        //all Audio Units in AUComponent.h must use
        //"kAudioUnitManufacturer_Apple" as the Manufacturer
        comp_desc.componentManufacturer = kAudioUnitManufacturer_Apple;
        comp_desc.componentFlags = 0;
        comp_desc.componentFlagsMask = 0;
 
        comp = AudioComponentFindNext(NULL, &comp_desc);
        if (!comp) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot find audio component!\n");
                goto error;
        }
        ret = AudioComponentInstanceNew(comp, &s->auHALComponentInstance);
        if (ret != noErr) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot open audio component: %s\n", get_osstatus_str(ret));
                goto error;
        }
 
        s->buffer = NULL;
 
        if ((ret = AudioUnitUninitialize(s->auHALComponentInstance)) != noErr) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot initialize audio unit: %s\n", get_osstatus_str(ret));
                goto error;
        }
 
        if (strcmp(cfg, "help") == 0) {
                audio_play_ca_help();
                delete s;
                return INIT_NOERR;
        }
        if (strlen(cfg) > 0) {
                try {
                        device = stoi(cfg);
                } catch (std::invalid_argument &e) {
                        device = audio_ca_get_device_by_name(cfg, CA_DIR);
                        if (device == UINT_MAX) {
                                log_msg(LOG_LEVEL_ERROR,
                                        MOD_NAME
                                        "Wrong device index "
                                        "or unrecognized name \"%s\"!\n",
                                        cfg);
                                goto error;
                        }
                }
        } else {
                AudioObjectPropertyAddress propertyAddress;
                UInt32 size = sizeof device;
                propertyAddress.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
                propertyAddress.mScope = kAudioObjectPropertyScopeGlobal;
                propertyAddress.mElement = kAudioObjectPropertyElementMain;
                if ((ret = AudioObjectGetPropertyData(kAudioObjectSystemObject, &propertyAddress, 0, NULL, &size, &device)) != noErr) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot get default audio device: %s\n", get_osstatus_str(ret));
                        goto error;
                }
        }
        char device_name[128];
        audio_ca_get_device_name(device, sizeof device_name, device_name);
        log_msg(LOG_LEVEL_INFO, MOD_NAME "Using device: %s\n", device_name);
 
        if (get_commandline_param("ca-disable-adaptive-buf") == nullptr &&
                        get_commandline_param("audio-disable-adaptive-buffer") == nullptr) {
                LOG(LOG_LEVEL_WARNING) << MOD_NAME "Using adaptive buffer. "
                        "In case of problems, try \"--param audio-disable-adaptive-buffer\" "
                        "option.\n";
        }
 
        ret = AudioUnitSetProperty(s->auHALComponentInstance,
                         kAudioOutputUnitProperty_CurrentDevice,
                         kAudioUnitScope_Global,
                         1,
                         &device,
                         sizeof(device));
        if (ret) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot set audio properties: %s\n", get_osstatus_str(ret));
                goto error;
        }
 
        return s;
 
error:
        delete s;
        return NULL;
}

References audio_ca_get_device_by_name(), audio_ca_get_device_name(), audio_play_ca_help(), state_ca_playback::auHALComponentInstance, state_ca_playback::buf_len_ms, state_ca_playback::buffer, CA_DIR, get_commandline_param(), get_osstatus_str(), INIT_NOERR, kAudioObjectPropertyElementMain, LOG, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, and val.

Here is the call graph for this function:

audio_play_ca_probe()

static void audio_play_ca_probe ( struct device_info ** available_devices, int * count, void(** deleter )(void *) )

static

Definition at line 382 of file coreaudio.cpp.

{
        *deleter = free;
        audio_ca_probe(available_devices, count, 1);
}

References audio_ca_probe(), count, and deleter.

Referenced by audio_play_ca_help().

Here is the call graph for this function:

audio_play_ca_put_frame()

static void audio_play_ca_put_frame ( void * state, const struct audio_frame * frame )

static

Definition at line 517 of file coreaudio.cpp.

{
        struct state_ca_playback *s = (struct state_ca_playback *)state;
 
        s->buffer_fns->write(s->buffer, frame->data, frame->data_len);
}

References state_ca_playback::buffer, state_ca_playback::buffer_fns, frame, state, and audio_buffer_api::write.

audio_play_ca_reconfigure()

static bool audio_play_ca_reconfigure ( void * state, struct audio_desc desc )

static

Definition at line 154 of file coreaudio.cpp.

{
        struct state_ca_playback *s = (struct state_ca_playback *)state;
        AudioStreamBasicDescription stream_desc;
        UInt32 size;
        OSStatus ret = noErr;
        AURenderCallbackStruct  renderStruct;
 
        LOG(LOG_LEVEL_NOTICE) << MOD_NAME "Audio reinitialized to " << desc.bps * 8 << "-bit, " << desc.ch_count << " channels, " << desc.sample_rate << " Hz\n";
 
        if (s->initialized) {
                ret = AudioOutputUnitStop(s->auHALComponentInstance);
                if(ret) {
                        LOG(LOG_LEVEL_ERROR) << MOD_NAME "Cannot stop AUHAL instance: " << get_osstatus_str(ret) << ".\n";
                        goto error;
                }
 
                ret = AudioUnitUninitialize(s->auHALComponentInstance);
                if(ret) {
                        LOG(LOG_LEVEL_ERROR) << MOD_NAME "Cannot uninitialize AUHAL instance: " << get_osstatus_str(ret) << ".\n";
                        goto error;
                }
                s->initialized = false;
        }
 
        s->desc = desc;
 
        if (s->buffer_fns) {
                s->buffer_fns->destroy(s->buffer);
                s->buffer_fns = nullptr;
                s->buffer = nullptr;
        }
 
        {
                if (get_commandline_param("audio-disable-adaptive-buffer") != nullptr || get_commandline_param("ca-disable-adaptive-buf") != nullptr) {
                        if (get_commandline_param("ca-disable-adaptive-buf") != nullptr) {
                                LOG(LOG_LEVEL_WARNING) << MOD_NAME "Param \"ca-disable-adaptive-buf\" is deprecated, use audio-disable-adaptive-bufer instead.\n";
                        }
                        int buf_len = desc.bps * desc.ch_count * (desc.sample_rate * s->buf_len_ms / 1000);
                        s->buffer = ring_buffer_init(buf_len);
                        s->buffer_fns = &ring_buffer_fns;
                } else {
                        s->buffer = audio_buffer_init(desc.sample_rate, desc.bps, desc.ch_count, s->buf_len_ms);
                        s->buffer_fns = &audio_buffer_fns;
                }
        }
 
        size = sizeof(stream_desc);
        ret = AudioUnitGetProperty(s->auHALComponentInstance, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input,
                        0, &stream_desc, &size);
        if(ret) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME "Cannot get device format from AUHAL instance: " << get_osstatus_str(ret) << ".\n";
                goto error;
        }
        stream_desc.mSampleRate = desc.sample_rate;
        stream_desc.mFormatID = kAudioFormatLinearPCM;
        stream_desc.mChannelsPerFrame = desc.ch_count;
        stream_desc.mBitsPerChannel = desc.bps * 8;
        stream_desc.mFormatFlags = kAudioFormatFlagIsSignedInteger|kAudioFormatFlagIsPacked;
        stream_desc.mFramesPerPacket = 1;
        s->audio_packet_size = stream_desc.mBytesPerFrame = stream_desc.mBytesPerPacket = stream_desc.mFramesPerPacket * desc.ch_count * desc.bps;
 
        ret = AudioUnitSetProperty(s->auHALComponentInstance, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input,
                        0, &stream_desc, sizeof(stream_desc));
        if(ret) {
                LOG(LOG_LEVEL_ERROR) << "Cannot set device format to AUHAL instance: " << get_osstatus_str(ret) << ".\n";
                goto error;
        }
 
        renderStruct.inputProc = theRenderProc;
        renderStruct.inputProcRefCon = s;
        ret = AudioUnitSetProperty(s->auHALComponentInstance, kAudioUnitProperty_SetRenderCallback,
                        kAudioUnitScope_Input, 0, &renderStruct, sizeof(AURenderCallbackStruct));
        if(ret) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME "Cannot register audio processing callback: " << get_osstatus_str(ret) << ".\n";
                goto error;
        }
 
        ret = AudioUnitInitialize(s->auHALComponentInstance);
        if(ret) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME "Cannot initialize AUHAL: " << get_osstatus_str(ret) << ".\n";
                goto error;
        }
 
        ret = AudioOutputUnitStart(s->auHALComponentInstance);
        if(ret) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME "Cannot start AUHAL: " << get_osstatus_str(ret) << ".\n";
                goto error;
        }
 
        s->initialized = true;
 
        return true;
 
error:
        return false;
}

References audio_buffer_fns, audio_buffer_init(), state_ca_playback::audio_packet_size, state_ca_playback::auHALComponentInstance, state_ca_playback::buf_len_ms, state_ca_playback::buffer, state_ca_playback::buffer_fns, desc, state_ca_playback::desc, audio_buffer_api::destroy, get_commandline_param(), get_osstatus_str(), state_ca_playback::initialized, LOG, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, LOG_LEVEL_WARNING, MOD_NAME, ring_buffer_fns, ring_buffer_init(), state, and theRenderProc().

Here is the call graph for this function:

is_requested_direction()

static bool is_requested_direction ( AudioObjectPropertyAddress propertyAddress, AudioDeviceID * audioDevice )

static

Definition at line 254 of file coreaudio.cpp.

                                                                                                           {
        // Determine if the device is an input/output device (it is an input/output device if it has input/output channels)
        UInt32 size = 0;
        OSStatus status;
        propertyAddress.mSelector = kAudioDevicePropertyStreamConfiguration;
        status = AudioObjectGetPropertyDataSize(*audioDevice, &propertyAddress, 0, NULL, &size);
        if(kAudioHardwareNoError != status) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME "AudioObjectGetPropertyDataSize (kAudioDevicePropertyStreamConfiguration) failed: " << status << "\n";
                return false;
        }
 
        AudioBufferList *bufferList = static_cast<AudioBufferList *>(malloc(size));
        if(NULL == bufferList) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME "Unable to allocate memory\n";
                return false;
        }
        status = AudioObjectGetPropertyData(*audioDevice, &propertyAddress, 0, NULL, &size, bufferList);
        if(kAudioHardwareNoError != status || 0 == bufferList->mNumberBuffers) {
                if(kAudioHardwareNoError != status)
                        LOG(LOG_LEVEL_ERROR) << MOD_NAME "AudioObjectGetPropertyData (kAudioDevicePropertyStreamConfiguration) failed: " << status << "\n";
                free(bufferList);
                return false;
        }
        free(bufferList);
        return true;
}

References LOG, LOG_LEVEL_ERROR, and MOD_NAME.

Referenced by audio_ca_probe().

REGISTER_MODULE()

REGISTER_MODULE	(	coreaudio	,
		&	aplay_coreaudio_info,
		LIBRARY_CLASS_AUDIO_PLAYBACK	,
		AUDIO_PLAYBACK_ABI_VERSION	)

theRenderProc()

static OSStatus theRenderProc ( void * inRefCon, AudioUnitRenderActionFlags * inActionFlags, const AudioTimeStamp * inTimeStamp, UInt32 inBusNumber, UInt32 inNumFrames, AudioBufferList * ioData )

static

Definition at line 97 of file coreaudio.cpp.

{
        UNUSED(inActionFlags);
        UNUSED(inTimeStamp);
        UNUSED(inBusNumber);
 
        struct state_ca_playback * s = (struct state_ca_playback *) inRefCon;
        int write_bytes = inNumFrames * s->audio_packet_size;
 
        int ret = s->buffer_fns->read(s->buffer, (char *) ioData->mBuffers[0].mData, write_bytes);
        ioData->mBuffers[0].mDataByteSize = ret;
 
        if(ret < write_bytes) {
                if (!s->quiet) {
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME "Audio buffer underflow (" << write_bytes << " requested, " << ret << " written).\n";
                }
                //memset(ioData->mBuffers[0].mData, 0, write_bytes);
                ioData->mBuffers[0].mDataByteSize = ret;
                if (!s->quiet && duration_cast<seconds>(steady_clock::now() - s->last_audio_read).count() > NO_DATA_STOP_SEC) {
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME "No data for " << NO_DATA_STOP_SEC << " seconds! Stopping.\n";
                        s->quiet = true;
                }
        } else {
                if (s->quiet) {
                        LOG(LOG_LEVEL_NOTICE) << MOD_NAME "Starting again.\n";
                }
                s->quiet = false;
                s->last_audio_read = steady_clock::now();
        }
        return noErr;
}

References state_ca_playback::audio_packet_size, state_ca_playback::buffer, state_ca_playback::buffer_fns, state_ca_playback::last_audio_read, LOG, LOG_LEVEL_NOTICE, LOG_LEVEL_WARNING, MOD_NAME, NO_DATA_STOP_SEC, state_ca_playback::quiet, audio_buffer_api::read, and UNUSED.

Referenced by audio_play_ca_reconfigure().

Variable Documentation

aplay_coreaudio_info

const struct audio_playback_info aplay_coreaudio_info

static

Initial value:

= {
        audio_play_ca_probe,
        audio_play_ca_init,
        audio_play_ca_put_frame,
        audio_play_ca_ctl,
        audio_play_ca_reconfigure,
        audio_play_ca_done
}

Definition at line 538 of file coreaudio.cpp.

                                                               {
        audio_play_ca_probe,
        audio_play_ca_init,
        audio_play_ca_put_frame,
        audio_play_ca_ctl,
        audio_play_ca_reconfigure,
        audio_play_ca_done
};

CA_DIR

int CA_DIR = 1

constexpr

Definition at line 75 of file coreaudio.cpp.

Referenced by audio_play_ca_init().

DEFAULT_BUFLEN_MS

int DEFAULT_BUFLEN_MS = 50

constexpr

Definition at line 74 of file coreaudio.cpp.