coreaudio.m File Reference

#include <AVFoundation/AVFoundation.h>
#include <AudioUnit/AudioUnit.h>
#include <Availability.h>
#include <CoreAudio/AudioHardware.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include "audio/audio_capture.h"
#include "audio/playback/coreaudio.h"
#include "audio/types.h"
#include "audio/utils.h"
#include "debug.h"
#include "host.h"
#include "lib_common.h"
#include "utils/color_out.h"
#include "utils/macos.h"
#include "utils/macros.h"
#include "utils/ring_buffer.h"

Include dependency graph for coreaudio.m:

Go to the source code of this file.

Classes
struct	state_ca_capture

Macros
#define	CA_STRINGIFY(A)
#define	CHECK_OK(cmd, msg, action_failed)
#define	MOD_NAME   "[CoreAudio cap.] "
#define	NOOP

Enumerations
enum	{ CA_DIR = -1 }

Functions
static AudioBufferList *	AllocateAudioBufferList (UInt32 numChannels, UInt32 size)
static void	audio_cap_ca_done (void *state)
static void	audio_cap_ca_help ()
static void *	audio_cap_ca_init (struct module *parent, const char *cfg)
static void	audio_cap_ca_probe (struct device_info **available_devices, int *count, void(**deleter)(void *))
static struct audio_frame *	audio_cap_ca_read (void *state)
static void	DestroyAudioBufferList (AudioBufferList *list)
static OSStatus	InputProc (void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList *ioData)
	REGISTER_MODULE (coreaudio, &acap_coreaudio_info, LIBRARY_CLASS_AUDIO_CAPTURE, AUDIO_CAPTURE_ABI_VERSION)

Variables
static const struct audio_capture_info	acap_coreaudio_info

Detailed Description

Author

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

Definition in file coreaudio.m.

Macro Definition Documentation

CA_STRINGIFY

#define CA_STRINGIFY

(

A

)

Value:

#A

Definition at line 184 of file coreaudio.m.

CHECK_OK

#define CHECK_OK	(		cmd,
			msg,
			action_failed )

Value:

        do { OSStatus ret = cmd; if (ret != noErr) {\
        log_msg(strlen(CA_STRINGIFY(action_failed)) == 0 ? LOG_LEVEL_WARNING : LOG_LEVEL_ERROR, MOD_NAME "%s: %s\n", (msg), get_osstatus_str(ret));\
        action_failed;\
}\
} while(0)

Definition at line 186 of file coreaudio.m.

#define CHECK_OK(cmd, msg, action_failed) do { OSStatus ret = cmd; if (ret != noErr) {\
        log_msg(strlen(CA_STRINGIFY(action_failed)) == 0 ? LOG_LEVEL_WARNING : LOG_LEVEL_ERROR, MOD_NAME "%s: %s\n", (msg), get_osstatus_str(ret));\
        action_failed;\
}\
} while(0)

Referenced by audio_cap_ca_init().

MOD_NAME

#define MOD_NAME   "[CoreAudio cap.] "

Definition at line 63 of file coreaudio.m.

Referenced by audio_cap_ca_init(), and InputProc().

NOOP

#define NOOP

Definition at line 191 of file coreaudio.m.

Referenced by ultragrid::aja::display::~display(), audio_cap_ca_init(), ultragrid::aja::display::RouteOutputSignal(), ultragrid::aja::display::SetUpAudio(), and ultragrid::aja::display::SetUpVideo().

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
CA_DIR

Definition at line 65 of file coreaudio.m.

     {
        CA_DIR = -1,
};

Function Documentation

AllocateAudioBufferList()

static AudioBufferList * AllocateAudioBufferList ( UInt32 numChannels, UInt32 size )

static

Definition at line 93 of file coreaudio.m.

{
        AudioBufferList*                        list;
        UInt32                                          i;
        
        list = (AudioBufferList*)calloc(1, sizeof(AudioBufferList) + numChannels * sizeof(AudioBuffer));
        if(list == NULL)
        return NULL;
        
        list->mNumberBuffers = numChannels;
        for(i = 0; i < numChannels; ++i) {
                list->mBuffers[i].mNumberChannels = 1;
                list->mBuffers[i].mDataByteSize = size;
                list->mBuffers[i].mData = malloc(size);
                if(list->mBuffers[i].mData == NULL) {
                        DestroyAudioBufferList(list);
                        return NULL;
                }
        }
        return list;
}

References DestroyAudioBufferList().

Referenced by audio_cap_ca_init().

Here is the call graph for this function:

audio_cap_ca_done()

static void audio_cap_ca_done ( void * state )

static

Definition at line 431 of file coreaudio.m.

{
        struct state_ca_capture *s = (struct state_ca_capture *) state;
 
        if(!s)
                return;
 
        pthread_mutex_destroy(&s->lock);
        pthread_cond_destroy(&s->cv);
        DestroyAudioBufferList(s->theBufferList);
        free(s->frame.data);
        ring_buffer_destroy(s->buffer);
        free(s->tmp);
 
        free(s);
}

References state_ca_capture::buffer, state_ca_capture::cv, audio_frame::data, DestroyAudioBufferList(), state_ca_capture::frame, state_ca_capture::lock, ring_buffer_destroy(), state, state_ca_capture::theBufferList, and state_ca_capture::tmp.

Here is the call graph for this function:

audio_cap_ca_help()

static void audio_cap_ca_help ( )

static

Definition at line 171 of file coreaudio.m.

{
        struct device_info *available_devices;
        int count;
        void (*deleter)(void *) = NULL;
        audio_cap_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_cap_ca_probe(), color_printf(), count, deleter, device_info::dev, name, and TBOLD.

Referenced by audio_cap_ca_init().

Here is the call graph for this function:

audio_cap_ca_init()

static void * audio_cap_ca_init ( struct module * parent, const char * cfg )

static

Definition at line 206 of file coreaudio.m.

{
        UNUSED(parent);
        if (strcmp(cfg, "help") == 0) {
                printf("Core Audio capture usage:\n");
                color_printf(TBOLD(TRED("\t-s coreaudio") "[:<index>|:<name>]") "\n");
                color_printf("where\n\t" TBOLD("<name>") " - device name substring (case sensitive)\n\n");
                printf("Available Core Audio capture devices:\n");
                audio_cap_ca_help();
                return INIT_NOERR;
        }
        OSStatus ret = noErr;
        AudioComponentDescription desc;
        AudioDeviceID device;
        UInt32 size = sizeof device;
 
        if (strlen(cfg) > 0) {
                char *endptr = NULL;
                device = strtol(cfg, &endptr, 0);
                if (*endptr != '\0') {
                        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);
                                return NULL;
                        }
                }
        } else {
                AudioObjectPropertyAddress propertyAddress;
                propertyAddress.mSelector = kAudioHardwarePropertyDefaultInputDevice;
                propertyAddress.mScope = kAudioObjectPropertyScopeGlobal;
                propertyAddress.mElement = kAudioObjectPropertyElementMain;
                if ((ret = AudioObjectGetPropertyData(kAudioObjectSystemObject, &propertyAddress, 0, NULL, &size, &device)) != 0) {
                        log_msg(LOG_LEVEL_ERROR, "Error finding default input device: %s.\n", get_osstatus_str(ret));
                        return NULL;
                }
        }
        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);
 
#ifdef __MAC_10_14
        AVAuthorizationStatus authorization_status = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeAudio];
        if (authorization_status == AVAuthorizationStatusRestricted ||
                        authorization_status == AVAuthorizationStatusDenied) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Application is not authorized to capture audio input!\n");
                return NULL;
        }
        if (authorization_status == AVAuthorizationStatusNotDetermined) {
                [AVCaptureDevice requestAccessForMediaType:AVMediaTypeAudio completionHandler:cb];
        }
#endif // defined __MAC_10_14
 
        double rate = 0.0;
        size = sizeof(double);
        AudioObjectPropertyAddress propertyAddress;
        propertyAddress.mSelector = kAudioDevicePropertyNominalSampleRate;
        propertyAddress.mScope = kAudioDevicePropertyScopeInput;
        propertyAddress.mElement = kAudioObjectPropertyElementMain;
        ret = AudioObjectGetPropertyData(device, &propertyAddress, 0, NULL, &size, &rate);
        if (ret != noErr || rate == 0.0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unable to get sample rate: %s. Wrong device index?\n", get_osstatus_str(ret));
                return NULL;
        }
        if (audio_capture_sample_rate != 0 && audio_capture_sample_rate != rate) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Requested sample rate %u, got %lf!\n", audio_capture_sample_rate, rate);
        }
 
        struct state_ca_capture *s = (struct state_ca_capture *) calloc(1, sizeof(struct state_ca_capture));
        pthread_mutex_init(&s->lock, NULL);
        pthread_cond_init(&s->cv, NULL);
        s->boss_waiting = FALSE;
        s->data_ready = FALSE;
        s->frame.bps = audio_capture_bps ? audio_capture_bps : 2;
        s->frame.ch_count = audio_capture_channels > 0 ? audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
 
        s->frame.sample_rate = rate;
        s->frame.max_size = s->frame.bps * s->frame.ch_count * s->frame.sample_rate;
        int nonres_channel_size = s->frame.bps * s->frame.sample_rate;
 
        s->theBufferList = AllocateAudioBufferList(s->frame.ch_count, nonres_channel_size);
        s->tmp = (char *) malloc(nonres_channel_size * s->frame.ch_count);
 
        s->buffer = ring_buffer_init(s->frame.max_size);
        s->frame.data = (char *) malloc(s->frame.max_size);
 
        //There are several different types of Audio Units.
        //Some audio units serve as Outputs, Mixers, or DSP
        //units. See AUComponent.h for listing
        desc.componentType = kAudioUnitType_Output;
 
        //Every Component has a subType, which will give a clearer picture
        //of what this components function will be.
        //desc.componentSubType = kAudioUnitSubType_DefaultOutput;
        desc.componentSubType = kAudioUnitSubType_HALOutput;
 
        //all Audio Units in AUComponent.h must use 
        //"kAudioUnitManufacturer_Apple" as the Manufacturer
        desc.componentManufacturer = kAudioUnitManufacturer_Apple;
        desc.componentFlags = 0;
        desc.componentFlagsMask = 0;
 
        bool failed = true;
        do {
                AudioComponent comp = AudioComponentFindNext(NULL, &desc);
                if(!comp) {
                        fprintf(stderr, "Error finding AUHAL component.\n");
                        break;
                }
                CHECK_OK(AudioComponentInstanceNew(comp, &s->auHALComponentInstance),
                                "Error opening AUHAL component",
                                break);
 
                //When using AudioUnitSetProperty the 4th parameter in the method
                //refer to an AudioUnitElement. When using an AudioOutputUnit
                //the input element will be '1' and the output element will be '0'.
 
                UInt32 enableIO = 1;
                CHECK_OK(AudioUnitSetProperty(s->auHALComponentInstance,
                                        kAudioOutputUnitProperty_EnableIO,
                                        kAudioUnitScope_Input,
                                        1, // input element
                                        &enableIO,
                                        sizeof(enableIO)),
                                "Error enabling input on AUHAL", break);
 
                enableIO = 0;
                CHECK_OK(AudioUnitSetProperty(s->auHALComponentInstance,
                                        kAudioOutputUnitProperty_EnableIO,
                                        kAudioUnitScope_Output,
                                        0,   //output element
                                        &enableIO,
                                        sizeof(enableIO)),
                                "Error disabling output on AUHAL", break);
 
                size=sizeof(device);
                CHECK_OK(AudioUnitSetProperty(s->auHALComponentInstance,
                                        kAudioOutputUnitProperty_CurrentDevice,
                                        kAudioUnitScope_Global,
                                        0,
                                        &device,
                                        sizeof(device)),
                                "Error setting device to AUHAL instance", break);
 
                AudioStreamBasicDescription desc;
 
                size = sizeof(desc);
                CHECK_OK(AudioUnitGetProperty(s->auHALComponentInstance, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input,
                                1, &desc, &size), "Error getting default device properties", break);
 
                desc.mChannelsPerFrame = s->frame.ch_count;
                desc.mSampleRate = (double) s->frame.sample_rate;
                desc.mFormatID = kAudioFormatLinearPCM;
                desc.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked | kAudioFormatFlagIsNonInterleaved;
                if (desc.mFormatID == kAudioFormatLinearPCM && s->frame.ch_count == 1)
                        desc.mFormatFlags &= ~kLinearPCMFormatFlagIsNonInterleaved;
 
/*#if __BIG_ENDIAN__
                desc.mFormatFlags |= kAudioFormatFlagIsBigEndian;
#endif */
                desc.mBitsPerChannel = s->frame.bps * 8;
                desc.mBytesPerFrame = desc.mBitsPerChannel / 8;
                desc.mFramesPerPacket = 1;
                desc.mBytesPerPacket = desc.mBytesPerFrame;
                s->audio_packet_size = desc.mBytesPerPacket;
 
                CHECK_OK(AudioUnitSetProperty(s->auHALComponentInstance, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output,
                                1, &desc, sizeof(desc)), "Error setting device properties", break);
 
                AURenderCallbackStruct input;
                input.inputProc = InputProc;
                input.inputProcRefCon = s;
                CHECK_OK(AudioUnitSetProperty(s->auHALComponentInstance, kAudioOutputUnitProperty_SetInputCallback,
                                kAudioUnitScope_Global, 0, &input, sizeof(input)),
                                "Error setting input callback", break);
                uint32_t numFrames = 128;
                if (get_commandline_param("audio-cap-frames")) {
                        numFrames = atoi(get_commandline_param("audio-cap-frames"));
                }
                CHECK_OK(AudioUnitSetProperty(s->auHALComponentInstance, kAudioDevicePropertyBufferFrameSize,
                                        kAudioUnitScope_Global, 0, &numFrames, sizeof(numFrames)),
                                        "Error setting frames", NOOP);
 
                CHECK_OK(AudioUnitInitialize(s->auHALComponentInstance), "Error initializing device", break);
                CHECK_OK(AudioOutputUnitStart(s->auHALComponentInstance), "Error starting device", break);
                failed = false;
        } while(0);
 
        if (!failed) {
                return s;
        }
 
        // error accured
        pthread_mutex_destroy(&s->lock);
        pthread_cond_destroy(&s->cv);
        DestroyAudioBufferList(s->theBufferList);
        free(s->frame.data);
        ring_buffer_destroy(s->buffer);
        free(s->tmp);
        free(s);
        return NULL;
}

References AllocateAudioBufferList(), audio_ca_get_device_by_name(), audio_ca_get_device_name(), audio_cap_ca_help(), audio_capture_bps, audio_capture_channels, audio_capture_sample_rate, state_ca_capture::audio_packet_size, state_ca_capture::auHALComponentInstance, state_ca_capture::boss_waiting, audio_frame::bps, state_ca_capture::buffer, CA_DIR, audio_frame::ch_count, CHECK_OK, color_printf(), state_ca_capture::cv, audio_frame::data, state_ca_capture::data_ready, DEFAULT_AUDIO_CAPTURE_CHANNELS, desc, DestroyAudioBufferList(), FALSE, state_ca_capture::frame, get_commandline_param(), get_osstatus_str(), INIT_NOERR, InputProc(), kAudioObjectPropertyElementMain, state_ca_capture::lock, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, log_msg(), audio_frame::max_size, MOD_NAME, NOOP, parent, ring_buffer_destroy(), ring_buffer_init(), audio_frame::sample_rate, TBOLD, state_ca_capture::theBufferList, state_ca_capture::tmp, TRED, and UNUSED.

Here is the call graph for this function:

audio_cap_ca_probe()

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

static

Definition at line 165 of file coreaudio.m.

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

References audio_ca_probe(), count, and deleter.

Referenced by audio_cap_ca_help().

Here is the call graph for this function:

audio_cap_ca_read()

static struct audio_frame * audio_cap_ca_read ( void * state )

static

Definition at line 408 of file coreaudio.m.

{
        struct state_ca_capture *s = (struct state_ca_capture *) state;
        int ret = FALSE;
 
        pthread_mutex_lock(&s->lock);
        ret = ring_buffer_read(s->buffer, s->frame.data, s->frame.max_size);
        if(!ret) {
                s->boss_waiting = TRUE;
                while(!s->data_ready) {
                        pthread_cond_wait(&s->cv, &s->lock);
                }
                s->boss_waiting = FALSE;
                ret = ring_buffer_read(s->buffer, s->frame.data, s->frame.max_size);
                s->data_ready = FALSE;
        }
        pthread_mutex_unlock(&s->lock);
 
        s->frame.data_len = ret;
 
        return &s->frame;
}

References state_ca_capture::boss_waiting, state_ca_capture::buffer, state_ca_capture::cv, audio_frame::data, audio_frame::data_len, state_ca_capture::data_ready, FALSE, state_ca_capture::frame, state_ca_capture::lock, audio_frame::max_size, ring_buffer_read(), state, and TRUE.

Here is the call graph for this function:

DestroyAudioBufferList()

static void DestroyAudioBufferList ( AudioBufferList * list )

static

Definition at line 116 of file coreaudio.m.

{
        UInt32                                          i;
        
        if(list) {
                for(i = 0; i < list->mNumberBuffers; i++) {
                        if(list->mBuffers[i].mData)
                        free(list->mBuffers[i].mData);
                }
                free(list);
        }
}

Referenced by AllocateAudioBufferList(), audio_cap_ca_done(), and audio_cap_ca_init().

InputProc()

static OSStatus InputProc ( void * inRefCon, AudioUnitRenderActionFlags * ioActionFlags, const AudioTimeStamp * inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList * ioData )

static

Definition at line 129 of file coreaudio.m.

{
        UNUSED(ioData);
        struct state_ca_capture * s = (struct state_ca_capture *) inRefCon;
 
        OSStatus err =noErr;
 
        err= AudioUnitRender(s->auHALComponentInstance, ioActionFlags, inTimeStamp, inBusNumber,     //will be '1' for input data
                inNumberFrames, //# of frames requested
                s->theBufferList);
 
        if(err == noErr) {
                int i;
                int len = inNumberFrames * s->audio_packet_size;
                for(i = 0; i < s->frame.ch_count; ++i)
                        mux_channel(s->tmp, s->theBufferList->mBuffers[i].mData, s->frame.bps, len, s->frame.ch_count, i, 1.0);
                uint32_t write_bytes = len * s->frame.ch_count;
 
                pthread_mutex_lock(&s->lock);
                ring_buffer_write(s->buffer, s->tmp, write_bytes);
                s->data_ready = TRUE;
                if(s->boss_waiting)
                        pthread_cond_signal(&s->cv);
                pthread_mutex_unlock(&s->lock);
        } else {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "writing buffer caused error %s.\n",  get_osstatus_str(err));
        }
 
        return err;
}

References state_ca_capture::audio_packet_size, state_ca_capture::auHALComponentInstance, state_ca_capture::boss_waiting, audio_frame::bps, state_ca_capture::buffer, audio_frame::ch_count, state_ca_capture::cv, state_ca_capture::data_ready, state_ca_capture::frame, get_osstatus_str(), len, state_ca_capture::lock, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, mux_channel(), ring_buffer_write(), state_ca_capture::theBufferList, state_ca_capture::tmp, TRUE, and UNUSED.

Referenced by audio_cap_ca_init().

Here is the call graph for this function:

REGISTER_MODULE()

REGISTER_MODULE	(	coreaudio	,
		&	acap_coreaudio_info,
		LIBRARY_CLASS_AUDIO_CAPTURE	,
		AUDIO_CAPTURE_ABI_VERSION	)

Variable Documentation

acap_coreaudio_info

const struct audio_capture_info acap_coreaudio_info

static

Initial value:

= {
        audio_cap_ca_probe,
        audio_cap_ca_init,
        audio_cap_ca_read,
        audio_cap_ca_done
}

Definition at line 448 of file coreaudio.m.

                                                             {
        audio_cap_ca_probe,
        audio_cap_ca_init,
        audio_cap_ca_read,
        audio_cap_ca_done
};