/* -*- c++ -*- */
/*
* Copyright 2006-2011,2013-2014 Free Software Foundation, Inc.
*
* This file is part of GNU Radio.
*
* GNU Radio is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3, or (at your option)
* any later version.
*
* GNU Radio is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Radio; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "audio_registry.h"
#include "osx_source.h"
#include <gnuradio/io_signature.h>
#include <gnuradio/prefs.h>
#include <stdexcept>
namespace gr {
namespace audio {
source::sptr
osx_source_fcn(int sampling_rate,
const std::string& device_name,
bool ok_to_block)
{
return source::sptr
(new osx_source(sampling_rate, device_name, ok_to_block));
}
static std::string
default_device_name()
{
return prefs::singleton()->get_string
("audio_osx", "default_input_device", "built-in");
}
osx_source::osx_source
(int sample_rate,
const std::string& device_name,
bool ok_to_block)
: sync_block("audio_osx_source",
io_signature::make(0, 0, 0),
io_signature::make(0, 0, 0)),
d_device_sample_rate(0.0), d_output_sample_rate(0.0),
d_input_buffer_size_frames(0), d_input_buffer_size_bytes(0),
d_output_buffer_size_frames(0), d_output_buffer_size_bytes(0),
d_device_buffer_size_frames(0), d_device_buffer_size_bytes(0),
d_lead_size_frames(0), d_lead_size_bytes(0),
d_trail_size_frames(0), d_trail_size_bytes(0),
d_extra_buffer_size_frames(0), d_extra_buffer_size_bytes(0),
d_queue_sample_count(0), d_buffer_sample_count(0),
d_n_available_input_frames(0), d_n_actual_input_frames(0),
d_n_user_channels(0), d_n_dev_channels(0),
d_ok_to_block(ok_to_block), d_pass_through(false),
d_waiting_for_data(false), d_do_reset(false),
d_hardware_changed(false), d_using_default_device(false),
d_desired_name(device_name.empty() ? default_device_name()
: device_name),
d_input_ad_id(0), d_input_au(0), d_input_buffer(0),
d_output_buffer(0), d_audio_converter(0)
{
// set the desired output sample rate
if(sample_rate <= 0) {
GR_LOG_ERROR(d_logger, boost::format
("Invalid Sample Rate: %d")
% sample_rate);
throw std::invalid_argument("audio_osx_source");
}
else {
d_output_sample_rate = (Float64)sample_rate;
}
// set up for audio input using the stored desired parameters
setup();
}
void osx_source::setup()
{
OSStatus err = noErr;
// set the default input audio device id to "unknown"
d_input_ad_id = kAudioDeviceUnknown;
// try to find the input audio device, if specified
std::vector < AudioDeviceID > all_ad_ids;
std::vector < std::string > all_names;
osx::find_audio_devices
(d_desired_name, true,
&all_ad_ids, &all_names);
// check number of device(s) returned
if (d_desired_name.length() != 0) {
if (all_ad_ids.size() == 1) {
// exactly 1 match was found; see if it was partial
if (all_names[0].compare(d_desired_name) != 0) {
// yes: log the full device name
GR_LOG_INFO(d_logger, boost::format
("Using input audio device '%s'.")
% all_names[0]);
}
// store info on this device
d_input_ad_id = all_ad_ids[0];
d_selected_name = all_names[0];
} else {
// either 0 or more than 1 device was found; get all input
// device names, print those, and error out.
osx::find_audio_devices("", true, NULL, &all_names);
std::string err_str("\n\nA unique input audio device name "
"matching the string '");
err_str += d_desired_name;
err_str += "' was not found.\n\n";
err_str += "The current known input audio device name";
err_str += ((all_names.size() > 1) ? "s are" : " is");
err_str += ":\n";
for (UInt32 nn = 0; nn < all_names.size(); ++nn) {
err_str += " " + all_names[nn] + "\n";
}
GR_LOG_ERROR(d_logger, boost::format(err_str));
throw std::runtime_error("audio_osx_source::setup");
}
}
// if no input audio device id was found or no specific device
// name was provided, use the default input audio device id as
// set in System Preferences.
if (d_input_ad_id == kAudioDeviceUnknown) {
UInt32 prop_size = (UInt32)sizeof(AudioDeviceID);
AudioObjectPropertyAddress ao_address = {
kAudioHardwarePropertyDefaultInputDevice,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster
};
err = AudioObjectGetPropertyData
(kAudioObjectSystemObject, &ao_address,
0, NULL, &prop_size, &d_input_ad_id);
check_error_and_throw
(err, "Getting the default input audio device ID failed",
"audio_osx_source::setup");
{
// retrieve the device name; max name length is 64 characters.
UInt32 prop_size = 65;
char c_name_buf[prop_size];
memset((void*)c_name_buf, 0, (size_t)prop_size);
--prop_size;
AudioObjectPropertyAddress ao_address = {
kAudioDevicePropertyDeviceName,
kAudioDevicePropertyScopeInput, 0
};
if ((err = AudioObjectGetPropertyData
(d_input_ad_id, &ao_address, 0, NULL,
&prop_size, (void*)c_name_buf)) != noErr) {
check_error(err, "Unable to retrieve input audio device name");
} else {
GR_LOG_INFO(d_logger, boost::format
("\n\nUsing input audio device '%s'.\n ... "
"which is the current default input audio"
" device.\n Changing the default input"
" audio device in the System Preferences"
" will \n result in changing it here, too "
"(with an internal reconfiguration).\n") %
std::string(c_name_buf));
}
d_selected_name = c_name_buf;
}
d_using_default_device = true;
}
// retrieve the total number of channels for the selected input
// audio device
osx::get_num_channels_for_audio_device_id
(d_input_ad_id, &d_n_dev_channels, NULL);
// set the block output signature, if not already set
// (d_n_user_channels is set in check_topology, which is called
// before the flow-graph is running)
if (d_n_user_channels == 0) {
set_output_signature(io_signature::make
(1, d_n_dev_channels, sizeof(float)));
}
// set the interim buffer size; to work with the GR scheduler,
// must be at least 16kB. Pick 50 kB since that's plenty yet
// not very much.
d_buffer_sample_count = (d_output_sample_rate < 50000.0 ?
50000 : (UInt32)d_output_sample_rate);
#if _OSX_AU_DEBUG_
std::cerr << "source(): max # samples = "
<< d_buffer_sample_count << std::endl;
#endif
// create the default AudioUnit for input
// Open the default input unit
#ifndef GR_USE_OLD_AUDIO_UNIT
AudioComponentDescription desc;
#else
ComponentDescription desc;
#endif
desc.componentType = kAudioUnitType_Output;
desc.componentSubType = kAudioUnitSubType_HALOutput;
desc.componentManufacturer = kAudioUnitManufacturer_Apple;
desc.componentFlags = 0;
desc.componentFlagsMask = 0;
#ifndef GR_USE_OLD_AUDIO_UNIT
AudioComponent comp = AudioComponentFindNext(NULL, &desc);
if(!comp) {
GR_LOG_FATAL(d_logger, boost::format
("AudioComponentFindNext Failed"));
throw std::runtime_error("audio_osx_source::setup");
}
err = AudioComponentInstanceNew(comp, &d_input_au);
check_error_and_throw(err, "AudioComponentInstanceNew Failed",
"audio_osx_source::setup");
#else
Component comp = FindNextComponent(NULL, &desc);
if(!comp) {
GR_LOG_FATAL(d_logger, boost::format
("FindNextComponent Failed"));
throw std::runtime_error("audio_osx_source::setup");
}
err = OpenAComponent(comp, &d_input_au);
check_error_and_throw(err, "OpenAComponent Failed",
"audio_osx_source::setup");
#endif
// must enable the AUHAL for input and disable output
// before setting the AUHAL's current device
// Enable input on the AUHAL
UInt32 enable_io = 1;
err = AudioUnitSetProperty
(d_input_au,
kAudioOutputUnitProperty_EnableIO,
kAudioUnitScope_Input, 1, // input element
&enable_io, sizeof(enable_io));
check_error_and_throw
(err, "AudioUnitSetProperty Input Enable",
"audio_osx_source::setup");
// Disable output on the AUHAL
enable_io = 0;
err = AudioUnitSetProperty
(d_input_au,
kAudioOutputUnitProperty_EnableIO,
kAudioUnitScope_Output, 0, // output element
&enable_io, sizeof(enable_io));
check_error_and_throw
(err, "AudioUnitSetProperty Output Disable",
"audio_osx_source::setup");
// set the selected device ID as the current input device
err = AudioUnitSetProperty
(d_input_au, kAudioOutputUnitProperty_CurrentDevice,
kAudioUnitScope_Global, 0,
&d_input_ad_id, sizeof(d_input_ad_id));
check_error_and_throw
(err, "Setting selected input device as current failed",
"audio_osx_source::setup");
// Set up a callback function to retrieve input from the Audio Device
AURenderCallbackStruct au_callback = {
reinterpret_cast<AURenderCallback>
(&osx_source::au_input_callback),
reinterpret_cast<void*>(this)
};
UInt32 prop_size = (UInt32)sizeof(au_callback);
err = AudioUnitSetProperty
(d_input_au,
kAudioOutputUnitProperty_SetInputCallback,
kAudioUnitScope_Global, 0,
&au_callback, prop_size);
check_error_and_throw
(err, "Set Input Callback",
"audio_osx_source::setup");
// Get the Stream Format (device side; cannot generally be changed)
prop_size = (UInt32)sizeof(d_asbd_device);
memset((void*)(&d_asbd_device), 0, (size_t)prop_size);
err = AudioUnitGetProperty
(d_input_au,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input, 1,
&d_asbd_device, &prop_size);
check_error_and_throw
(err, "Get Device Input Stream Format (before) failed",
"audio_osx_source::setup");
#if _OSX_AU_DEBUG_
std::cerr << std::endl << "---- Device Stream Format (before) ----"
<< std::endl << d_asbd_device << std::endl << std::endl;
#endif
// try to set the device (input) side of the audio device to the
// sample rate of this source. This will likely fail, and
// that's OK; just ignore the error since we can accomplish
// audio input in other ways.
prop_size = (UInt32)sizeof(d_asbd_device);
d_asbd_device.mSampleRate = d_output_sample_rate;
err = AudioUnitSetProperty
(d_input_au,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input, 1,
&d_asbd_device, prop_size);
#if _OSX_AU_DEBUG_
check_error
(err, "Set Device Input Stream Format failed (expected)");
#endif
memset((void*)(&d_asbd_device), 0, (size_t)prop_size);
err = AudioUnitGetProperty
(d_input_au,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input, 1,
&d_asbd_device, &prop_size);
check_error_and_throw
(err, "Get Device Input Stream Format (after) failed",
"audio_osx_source::setup");
#if _OSX_AU_DEBUG_
std::cerr << std::endl << "---- Device Stream Format (after) ----"
<< std::endl << d_asbd_device << std::endl << std::endl;
#endif
d_device_sample_rate = d_asbd_device.mSampleRate;
// Get the Stream Format (client side; might be changeable)
prop_size = (UInt32)sizeof(d_asbd_client);
memset((void*)(&d_asbd_client), 0, (size_t)prop_size);
err = AudioUnitGetProperty
(d_input_au,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Output, 1,
&d_asbd_client, &prop_size);
check_error_and_throw
(err, "Get Device Output Stream Format (before) failed",
"audio_osx_source::setup");
#if _OSX_AU_DEBUG_
std::cerr << "---- Client Stream Format (Before) ----"
<< std::endl << d_asbd_client << std::endl << std::endl;
#endif
// Set the format of all the AUs to the
// input/output devices channel count
d_asbd_client.mFormatID = kAudioFormatLinearPCM;
d_asbd_client.mFormatFlags = (kAudioFormatFlagIsFloat |
kAudioFormatFlagIsPacked |
kAudioFormatFlagIsNonInterleaved);
if((d_asbd_client.mFormatID == kAudioFormatLinearPCM) &&
(d_n_dev_channels == 1)) {
d_asbd_client.mFormatFlags &= ~kLinearPCMFormatFlagIsNonInterleaved;
}
d_asbd_client.mBytesPerFrame = (UInt32)sizeof(float);
d_asbd_client.mFramesPerPacket = 1;
d_asbd_client.mBitsPerChannel = d_asbd_client.mBytesPerFrame * 8;
d_asbd_client.mChannelsPerFrame = d_n_dev_channels;
d_asbd_client.mBytesPerPacket = d_asbd_client.mBytesPerFrame;
// according to Apple docs [see, e.g., Apple Technical Note
// TN2091 "Device input using the HAL Output Audio Unit"], the
// device input and output sample rate must be the same; do
// sample rate conversion elsewhere.
d_asbd_client.mSampleRate = d_asbd_device.mSampleRate;
err = AudioUnitSetProperty
(d_input_au,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Output, 1,
&d_asbd_client, prop_size);
check_error_and_throw
(err, "Set Device Output Stream Format failed",
"audio_osx_source::setup");
// Get the Stream Format (client side), again
prop_size = (UInt32)sizeof(d_asbd_client);
memset((void*)(&d_asbd_client), 0, (size_t)prop_size);
err = AudioUnitGetProperty
(d_input_au,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Output, 1,
&d_asbd_client, &prop_size);
check_error_and_throw
(err, "Get Device Output Stream Format (after) failed",
"audio_osx_source::setup");
#if _OSX_AU_DEBUG_
std::cerr << "---- Client Stream Format (After) ----"
<< std::endl << d_asbd_client << std::endl << std::endl;
#endif
d_pass_through = (d_asbd_client.mSampleRate == d_output_sample_rate);
if (d_pass_through) {
// no need to do conversion if d_asbd_client matches user wants
d_lead_size_frames = d_trail_size_frames = 0L;
}
else {
// create an ASBD for the user's wants
memset((void*)(&d_asbd_user), 0, sizeof(d_asbd_user));
d_asbd_user.mSampleRate = d_output_sample_rate;
d_asbd_user.mFormatID = kAudioFormatLinearPCM;
d_asbd_user.mFormatFlags = (kLinearPCMFormatFlagIsFloat |
GR_PCM_ENDIANNESS |
kLinearPCMFormatFlagIsPacked |
kAudioFormatFlagIsNonInterleaved);
d_asbd_user.mBytesPerPacket = (UInt32)sizeof(float);
d_asbd_user.mFramesPerPacket = 1;
d_asbd_user.mBytesPerFrame = d_asbd_user.mBytesPerPacket;
d_asbd_user.mChannelsPerFrame = d_n_dev_channels;
d_asbd_user.mBitsPerChannel = d_asbd_user.mBytesPerPacket * 8;
// Create the audio converter
err = AudioConverterNew(&d_asbd_client,
&d_asbd_user,
&d_audio_converter);
check_error_and_throw
(err, "AudioConverterNew failed",
"audio_osx_source::setup");
// Set the audio converter sample rate quality to "max" ...
// requires more samples, but should sound nicer
UInt32 ac_quality = kAudioConverterQuality_Max;
prop_size = (UInt32)sizeof(ac_quality);
err = AudioConverterSetProperty
(d_audio_converter,
kAudioConverterSampleRateConverterQuality,
prop_size, &ac_quality);
check_error_and_throw
(err, "Set Sample Rate Converter Quality failed",
"audio_osx_source::setup");
// set the audio converter's prime method to "pre",
// which uses both leading and trailing frames
// from the "current input". All of this is handled
// internally by the AudioConverter; we just supply
// the frames for conversion.
UInt32 ac_prime_method = kConverterPrimeMethod_Pre;
prop_size = (UInt32)sizeof(ac_prime_method);
err = AudioConverterSetProperty
(d_audio_converter,
kAudioConverterPrimeMethod,
prop_size, &ac_prime_method);
check_error_and_throw
(err, "Set Prime Method failed",
"audio_osx_source::setup");
// Get the size of the priming I/O buffer space to allow for
// pre-allocated buffers
AudioConverterPrimeInfo ac_prime_info = {0, 0};
prop_size = (UInt32)sizeof(ac_prime_info);
err = AudioConverterGetProperty
(d_audio_converter,
kAudioConverterPrimeInfo,
&prop_size, &ac_prime_info);
check_error_and_throw
(err, "Get Prime Info failed",
"audio_osx_source::setup");
d_lead_size_frames = ac_prime_info.leadingFrames;
d_trail_size_frames = ac_prime_info.trailingFrames;
}
d_lead_size_bytes = d_lead_size_frames * sizeof(float);
d_trail_size_bytes = d_trail_size_frames * sizeof(float);
prop_size = (UInt32)sizeof(d_device_buffer_size_frames);
err = AudioUnitGetProperty
(d_input_au,
kAudioDevicePropertyBufferFrameSize,
kAudioUnitScope_Global, 0,
&d_device_buffer_size_frames, &prop_size);
check_error_and_throw
(err, "Get Buffer Frame Size failed",
"audio_osx_source::setup");
d_device_buffer_size_bytes = (d_device_buffer_size_frames *
sizeof(float));
d_input_buffer_size_bytes = (d_device_buffer_size_bytes +
d_lead_size_bytes);
d_input_buffer_size_frames = (d_device_buffer_size_frames +
d_lead_size_frames);
// outBufSizeBytes = floor (inBufSizeBytes * rate_out / rate_in)
// since this is rarely exact, we need another buffer to hold
// "extra" samples not processed at any given sampling period
// this buffer must be at least 4 floats in size, but generally
// follows the rule that
// extraBufSize = ceil (rate_in / rate_out)*sizeof(float)
d_extra_buffer_size_frames =
((UInt32)ceil(d_device_sample_rate /
d_output_sample_rate) *
sizeof(float));
if(d_extra_buffer_size_frames < 4)
d_extra_buffer_size_frames = 4;
d_extra_buffer_size_bytes =
d_extra_buffer_size_frames * sizeof(float);
d_output_buffer_size_frames =
(UInt32)ceil(((Float64)d_input_buffer_size_frames) *
d_output_sample_rate / d_device_sample_rate);
d_output_buffer_size_bytes =
d_output_buffer_size_frames * sizeof(float);
d_input_buffer_size_frames += d_extra_buffer_size_frames;
// pre-alloc all CoreAudio buffers
alloc_audio_buffer_list
(&d_input_buffer, d_n_dev_channels,
d_input_buffer_size_bytes);
if(!d_pass_through) {
alloc_audio_buffer_list
(&d_output_buffer, d_n_dev_channels,
d_output_buffer_size_bytes);
}
else {
d_output_buffer = d_input_buffer;
}
// allocate the output circular buffer(s), one per device
// channel (the user may select fewer channels; those buffers
// just won't get used).
d_buffers.resize(d_n_dev_channels);
for(UInt32 nn = 0; nn < d_n_dev_channels; ++nn) {
d_buffers[nn] = new circular_buffer<float>
(d_buffer_sample_count, false, false);
}
// clear the RunLoop (whatever that is); needed, for some
// reason, before a listener will work.
{
CFRunLoopRef the_run_loop = NULL;
AudioObjectPropertyAddress property = {
kAudioHardwarePropertyRunLoop,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster
};
prop_size = (UInt32)sizeof(the_run_loop);
err = AudioObjectSetPropertyData
(kAudioObjectSystemObject, &property, 0, NULL,
prop_size, &the_run_loop);
check_error(err, "Clearing RunLoop failed; "
"Audio Input Device Listener might not work.");
}
// set up listeners
#ifndef GR_USE_OLD_AUDIO_UNIT
// 10.4 and newer
{
// set up a listener if hardware changes (at all)
AudioObjectPropertyAddress property = {
kAudioHardwarePropertyDevices,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster
};
err = AudioObjectAddPropertyListener
(kAudioObjectSystemObject, &property,
reinterpret_cast<AudioObjectPropertyListenerProc>
(&osx_source::hardware_listener),
reinterpret_cast<void*>(this));
check_error(err, "Adding Audio Hardware Listener failed");
}
if (d_using_default_device) {
// set up a listener if default hardware input device changes
AudioObjectPropertyAddress property = {
kAudioHardwarePropertyDefaultInputDevice,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster
};
err = AudioObjectAddPropertyListener
(kAudioObjectSystemObject, &property,
reinterpret_cast<AudioObjectPropertyListenerProc>
(&osx_source::default_listener),
reinterpret_cast<void*>(this));
check_error(err, "Adding Default Input Audio Listener failed");
}
#else
// 10.5 and older
err = AudioHardwareAddPropertyListener
(kAudioHardwarePropertyDevices,
reinterpret_cast<AudioHardwarePropertyListenerProc>
(&osx_source::hardware_listener),
reinterpret_cast<void*>(this));
check_error(err, "Adding Audio Hardware Listener failed");
if (d_using_default_device) {
err = AudioHardwareAddPropertyListener
(kAudioHardwarePropertyDefaultInputDevice,
reinterpret_cast<AudioHardwarePropertyListenerProc>
(&osx_source::default_listener),
reinterpret_cast<void*>(this));
check_error(err, "Adding Default Input Audio Listener failed");
}
#endif
// initialize the AU for input, so that it is ready to be used
err = AudioUnitInitialize(d_input_au);
check_error_and_throw
(err, "AudioUnitInitialize",
"audio_osx_source::check_channels");
#if _OSX_AU_DEBUG_
std::cerr << std::endl << "audio_osx_source Parameters:"
<< std::endl << " Device Sample Rate is "
<< d_device_sample_rate << std::endl
<< " Client Sample Rate is "
<< (d_pass_through ? d_output_sample_rate :
d_device_sample_rate) << std::endl
<< " User Sample Rate is "
<< d_output_sample_rate << std::endl
<< " Do Passthrough is "
<< (d_pass_through ? "true" : "false") << std::endl
<< " Max Sample Count is "
<< d_buffer_sample_count << std::endl
<< " # Device Channels is "
<< d_n_dev_channels << std::endl
<< " Device Buffer Size in Frames = "
<< d_device_buffer_size_frames << std::endl
<< " Lead Size in Frames = "
<< d_lead_size_frames << std::endl
<< " Trail Size in Frames = "
<< d_trail_size_frames << std::endl
<< " Input Buffer Size in Frames = "
<< d_input_buffer_size_frames << std::endl
<< " Output Buffer Size in Frames = "
<< d_output_buffer_size_frames << std::endl
<< std::endl;
#endif
}
void
osx_source::alloc_audio_buffer_list
(AudioBufferList** t_abl,
UInt32 n_channels,
UInt32 input_buffer_size_bytes)
{
free_audio_buffer_list(t_abl);
UInt32 prop_size = (offsetof(AudioBufferList, mBuffers[0]) +
(sizeof(AudioBuffer) * n_channels));
*t_abl = (AudioBufferList*)calloc(1, prop_size);
(*t_abl)->mNumberBuffers = n_channels;
int counter = n_channels;
#if _OSX_AU_DEBUG_
std::cerr << "alloc_audio_buffer_list: (#chan, #bytes) == ("
<< n_channels << ", " << input_buffer_size_bytes
<< ")" << std::endl;
#endif
while(--counter >= 0) {
AudioBuffer* t_ab = &((*t_abl)->mBuffers[counter]);
t_ab->mNumberChannels = 1;
t_ab->mDataByteSize = input_buffer_size_bytes;
t_ab->mData = calloc(1, input_buffer_size_bytes);
}
}
void
osx_source::free_audio_buffer_list(AudioBufferList** t_abl)
{
// free pre-allocated audio buffer, if it exists
if(*t_abl) {
int counter = (*t_abl)->mNumberBuffers;
while(--counter >= 0) {
AudioBuffer* t_ab = &((*t_abl)->mBuffers[counter]);
free(t_ab->mData);
t_ab->mData = 0;
}
free(*t_abl);
(*t_abl) = 0;
}
}
bool
osx_source::is_running()
{
UInt32 au_running = 0;
if (d_input_au) {
UInt32 prop_size = (UInt32)sizeof(au_running);
OSStatus err = AudioUnitGetProperty
(d_input_au,
kAudioOutputUnitProperty_IsRunning,
kAudioUnitScope_Global, 0,
&au_running, &prop_size);
check_error_and_throw
(err, "AudioUnitGetProperty IsRunning",
"audio_osx_source::is_running");
}
return(au_running != 0);
}
bool
osx_source::start()
{
#if _OSX_AU_DEBUG_
std::cerr << ((void*)(pthread_self()))
<< " : audio_osx_source::start: Starting." << std::endl;
#endif
if((!is_running ()) && d_input_au) {
#if _OSX_AU_DEBUG_
std::cerr << ((void*)(pthread_self()))
<< " : audio_osx_source::start: Starting Audio Unit."
<< std::endl;
#endif
// reset buffers before starting
for(UInt32 nn = 0; nn < d_buffers.size(); ++nn) {
d_buffers[nn]->reset();
}
// start the audio unit
OSStatus err = AudioOutputUnitStart(d_input_au);
check_error_and_throw(err, "AudioOutputUnitStart",
"audio_osx_source::start");
// clear reset (will sometimes be necessary, and it has to
// happen after AudioOutputUnitStart)
d_do_reset = false;
}
#if _OSX_AU_DEBUG_
std::cerr << ((void*)(pthread_self()))
<< " : audio_osx_source::start: Returning." << std::endl;
#endif
return (true);
}
bool
osx_source::stop()
{
#if _OSX_AU_DEBUG_
std::cerr << ((void*)(pthread_self()))
<< " : audio_osx_source::stop: Starting." << std::endl;
#endif
if(is_running ()) {
#if _OSX_AU_DEBUG_
std::cerr << ((void*)(pthread_self()))
<< " : audio_osx_source::stop: stopping audio unit."
<< std::endl;
#endif
// stop the audio unit
OSStatus err = AudioOutputUnitStop(d_input_au);
check_error_and_throw(err, "AudioOutputUnitStart",
"audio_osx_source::stop");
// abort all buffers
for(UInt32 nn = 0; nn < d_n_user_channels; ++nn) {
d_buffers[nn]->abort ();
}
}
#if _OSX_AU_DEBUG_
std::cerr << ((void*)(pthread_self()))
<< " : audio_osx_source::stop: Returning." << std::endl;
#endif
return (true);
}
void
osx_source::teardown()
{
#if _OSX_AU_DEBUG_
std::cerr << ((void*)(pthread_self()))
<< " : audio_osx_source::teardown: Starting." << std::endl;
#endif
OSStatus err = noErr;
// stop the AudioUnit
stop();
// remove the listeners
#ifndef GR_USE_OLD_AUDIO_UNIT
// 10.4 and newer
{
AudioObjectPropertyAddress property = {
kAudioHardwarePropertyDevices,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster
};
err = AudioObjectRemovePropertyListener
(kAudioObjectSystemObject, &property,
reinterpret_cast<AudioObjectPropertyListenerProc>
(&osx_source::hardware_listener),
reinterpret_cast<void*>(this));
#if _OSX_AU_DEBUG_
check_error(err, "teardown: AudioObjectRemovePropertyListener "
"hardware failed");
#endif
}
if (d_using_default_device) {
AudioObjectPropertyAddress property = {
kAudioHardwarePropertyDefaultInputDevice,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster
};
err = AudioObjectRemovePropertyListener
(kAudioObjectSystemObject, &property,
reinterpret_cast<AudioObjectPropertyListenerProc>
(&osx_source::default_listener),
reinterpret_cast<void*>(this));
#if _OSX_AU_DEBUG_
check_error(err, "AudioObjectRemovePropertyListener default");
#endif
d_using_default_device = false;
}
#else
// 10.5 and older
err = AudioHardwareRemovePropertyListener
(kAudioHardwarePropertyDevices,
reinterpret_cast<AudioHardwarePropertyListenerProc>
(&osx_source::hardware_listener));
#if _OSX_AU_DEBUG_
check_error(err, "AudioObjectRemovePropertyListener hardware");
#endif
if (d_using_default_device) {
err = AudioHardwareRemovePropertyListener
(kAudioHardwarePropertyDefaultInputDevice,
reinterpret_cast<AudioHardwarePropertyListenerProc>
(&osx_source::default_listener));
#if _OSX_AU_DEBUG_
check_error(err, "AudioObjectRemovePropertyListener default");
#endif
d_using_default_device = false;
}
#endif // GR_USE_OLD_AUDIO_UNIT
// free pre-allocated audio buffers
free_audio_buffer_list(&d_input_buffer);
if(!d_pass_through) {
err = AudioConverterDispose(d_audio_converter);
#if _OSX_AU_DEBUG_
check_error(err, "~audio_osx_source: AudioConverterDispose");
#endif
free_audio_buffer_list(&d_output_buffer);
}
// remove the audio unit
err = AudioUnitUninitialize(d_input_au);
#if _OSX_AU_DEBUG_
check_error(err, "~audio_osx_source: AudioUnitUninitialize");
#endif
#ifndef GR_USE_OLD_AUDIO_UNIT
err = AudioComponentInstanceDispose(d_input_au);
#if _OSX_AU_DEBUG_
check_error(err, "~audio_osx_source: AudioComponentInstanceDispose");
#endif
#else
err = CloseComponent(d_input_au);
#if _OSX_AU_DEBUG_
check_error(err, "~audio_osx_source: CloseComponent");
#endif
#endif
// empty and delete the queues
for(UInt32 nn = 0; nn < d_buffers.size(); ++nn) {
delete d_buffers[nn];
d_buffers[nn] = 0;
}
d_buffers.resize(0);
// clear important variables; not # user channels
d_queue_sample_count = 0;
d_device_sample_rate = 0;
d_n_dev_channels = 0;
d_input_ad_id = 0;
d_input_au = 0;
d_input_buffer = d_output_buffer = 0;
d_audio_converter = 0;
d_using_default_device = false;
#if _OSX_AU_DEBUG_
std::cerr << ((void*)(pthread_self()))
<< " : audio_osx_source::teardown: Returning." << std::endl;
#endif
}
bool
osx_source::check_topology(int ninputs, int noutputs)
{
// check # inputs to make sure it's valid
if(ninputs != 0) {
GR_LOG_FATAL(d_logger, boost::format
("check_topology(): number of input "
"streams provided (%d) should be 0.")
% ninputs);
throw std::runtime_error
("audio_osx_source::check_topology");
}
// check # outputs to make sure it's valid
if((noutputs < 1) | (noutputs > (int) d_n_dev_channels)) {
GR_LOG_FATAL(d_logger, boost::format
("check_topology(): number of output "
"streams provided (%d) should be in [1,%d] "
"for the selected input audio device.")
% noutputs % d_n_dev_channels);
throw std::runtime_error
("audio_osx_source::check_topology");
}
// save the actual number of output (user) channels
d_n_user_channels = noutputs;
#if _OSX_AU_DEBUG_
std::cerr << "chk_topo: Actual # user output channels = "
<< noutputs << std::endl;
#endif
return(true);
}
int
osx_source::work(int noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items)
{
#if _OSX_AU_DEBUG_RENDER_
std::cerr << ((void*)(pthread_self()))
<< " : audio_osx_source::work: Starting." << std::endl;
#endif
if (d_do_reset) {
if (d_hardware_changed) {
// see if the current AudioDeviceID is still available
std::vector < AudioDeviceID > all_ad_ids;
osx::find_audio_devices
(d_desired_name, true,
&all_ad_ids, NULL);
bool found = false;
for (UInt32 nn = 0; (nn < all_ad_ids.size()) && (!found);
++nn) {
found = (all_ad_ids[nn] == d_input_ad_id);
}
if (!found) {
GR_LOG_FATAL(d_logger, boost::format
("The selected input audio device ('%s') "
"is no longer available.\n")
% d_selected_name);
return(gr::block::WORK_DONE);
}
d_do_reset = d_hardware_changed = false;
} else {
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "audio_osx_source::work: doing reset."
<< std::endl;
#endif
GR_LOG_WARN(d_logger, boost::format
("\n\nThe default input audio device has "
"changed; resetting audio.\nThere may "
"be a sound glitch while resetting.\n"));
// for any changes, just tear down the current
// configuration, then set it up again using the user's
// parameters to try to make selections.
teardown();
gr::thread::scoped_lock l(d_internal);
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "audio_osx_source::work: mutex locked."
<< std::endl;
#endif
setup();
start();
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "audio_osx_source::work: returning after reset."
<< std::endl;
#endif
return(0);
}
}
gr::thread::scoped_lock l(d_internal);
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "audio_osx_source::work: mutex locked." << std::endl;
#endif
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "work1: SC = " << d_queue_sample_count
<< ", #OI = " << noutput_items
<< ", #Chan = " << output_items.size() << std::endl;
#endif
// set the actual # of output items to the 'desired' amount then
// verify that data is available; if not enough data is
// available, either wait until it is (is "ok_to_block" is
// true), return (0) is no data is available and "ok_to_block"
// is false, or process the actual amount of available data.
UInt32 actual_noutput_items = noutput_items;
if(d_queue_sample_count < actual_noutput_items) {
if(d_queue_sample_count == 0) {
// no data; ok_to_block decides what to do
if(d_ok_to_block == true) {
// block until there is data to return, or on reset
while(d_queue_sample_count == 0) {
// release control so-as to allow data to be retrieved;
// block until there is data to return
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "audio_osx_source::work: waiting."
<< std::endl;
#endif
d_waiting_for_data = true;
d_cond_data.wait(l);
d_waiting_for_data = false;
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "audio_osx_source::work: done waiting."
<< std::endl;
#endif
// the condition's 'notify' was called; acquire control to
// keep thread safe
// if doing a reset, just return here; reset will pick
// up the next time this method is called.
if (d_do_reset) {
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "audio_osx_source::work: "
"returning for reset." << std::endl;
#endif
return(0);
}
}
}
else {
// no data & not blocking; return nothing
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "audio_osx_source::work: no data "
"& not blocking; returning 0." << std::endl;
#endif
return (0);
}
}
// use the actual amount of available data
actual_noutput_items = d_queue_sample_count;
}
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "audio_osx_source::work: copying "
<< actual_noutput_items << " items per channel"
<< std::endl;
#endif
// number of channels
int l_counter = (int)output_items.size();
// copy the items from the circular buffer(s) to 'work's output
// buffers; verify that the number copied out is as expected.
while(--l_counter >= 0) {
size_t t_n_output_items = actual_noutput_items;
d_buffers[l_counter]->dequeue
((float*)output_items[l_counter],
&t_n_output_items);
if(t_n_output_items != actual_noutput_items) {
GR_LOG_FATAL(d_logger, boost::format
("work(): ERROR: number of available "
"items changing unexpectedly; expecting %d"
", got %d.")
% actual_noutput_items % t_n_output_items);
throw std::runtime_error("audio_osx_source::work()");
}
}
// subtract the actual number of items removed from the buffer(s)
// from the local accounting of the number of available samples
d_queue_sample_count -= actual_noutput_items;
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "work2: SC = " << d_queue_sample_count
<< ", act#OI = " << actual_noutput_items << std::endl
<< "Returning." << std::endl;
#endif
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "audio_osx_source::work: returning." << std::endl;
#endif
return (actual_noutput_items);
}
OSStatus
osx_source::converter_callback
(AudioConverterRef in_audio_converter,
UInt32* io_number_data_packets,
AudioBufferList* io_data,
AudioStreamPacketDescription** out_aspd,
void* in_user_data)
{
// This callback is for us to provide the buffers to CoreAudio
// for conversion. We need to set the buffers in the provided
// buffer list (io_data) to the buffers we know about and use to
// do data input (d_input_buffers).
osx_source* This = static_cast<osx_source*>(in_user_data);
AudioBufferList* l_input_abl = This->d_input_buffer;
UInt32 total_input_buffer_size_bytes =
((*io_number_data_packets) * sizeof(float));
int counter = This->d_n_dev_channels;
io_data->mNumberBuffers = This->d_n_dev_channels;
This->d_n_actual_input_frames = (*io_number_data_packets);
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "cc1: io#DP = " << (*io_number_data_packets)
<< ", TIBSB = " << total_input_buffer_size_bytes
<< ", #C = " << counter << std::endl;
#endif
while(--counter >= 0) {
AudioBuffer* t_ab = &(io_data->mBuffers[counter]);
t_ab->mNumberChannels = 1;
t_ab->mData = l_input_abl->mBuffers[counter].mData;
t_ab->mDataByteSize = total_input_buffer_size_bytes;
}
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "cc2: Returning." << std::endl;
#endif
return (noErr);
}
OSStatus
osx_source::au_input_callback
(void *in_ref_con,
AudioUnitRenderActionFlags *io_action_flags,
const AudioTimeStamp *in_time_stamp,
UInt32 in_bus_number,
UInt32 in_number_frames,
AudioBufferList *io_data)
{
#if _OSX_AU_DEBUG_RENDER_
std::cerr << ((void*)(pthread_self()))
<< " : audio_osx_source::au_input_callback: Starting."
<< std::endl;
#endif
osx_source* This = reinterpret_cast
<osx_source*>(in_ref_con);
gr::thread::scoped_lock l(This->d_internal);
gr::logger_ptr d_logger = This->d_logger;
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "audio_osx_source::au_input_callback: mutex locked."
<< std::endl;
#endif
OSStatus err = noErr;
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "cb0: in#Fr = " << in_number_frames
<< ", inBus# = " << in_bus_number
<< ", idD = " << ((void*)io_data)
<< ", d_ib = " << ((void*)(This->d_input_buffer))
<< ", d_ib#c = " << This->d_input_buffer->mNumberBuffers
<< ", SC = " << This->d_queue_sample_count << std::endl;
#endif
if (This->d_do_reset) {
// clear audio data; do not render since it will generate an error
AudioBufferList* t_abl = This->d_input_buffer;
for (UInt32 nn = 0; nn < t_abl->mNumberBuffers; ++nn) {
AudioBuffer* t_ab = &(t_abl->mBuffers[nn]);
memset(t_ab->mData, 0, (size_t)((t_ab->mDataByteSize) *
(t_ab->mNumberChannels)));
}
} else {
// Get the new audio data from the input device
err = AudioUnitRender
(This->d_input_au, io_action_flags,
in_time_stamp, 1, //inBusNumber,
in_number_frames, This->d_input_buffer);
check_error_and_throw
(err, "AudioUnitRender",
"audio_osx_source::au_input_callback");
}
UInt32 available_input_frames =
This->d_n_available_input_frames = in_number_frames;
// get the number of actual output frames,
// either via converting the buffer or not
UInt32 actual_output_frames = available_input_frames;
if(!This->d_pass_through) {
UInt32 available_input_bytes =
available_input_frames * sizeof(float);
UInt32 available_output_bytes = available_input_bytes;
UInt32 prop_size = sizeof(available_output_bytes);
err = AudioConverterGetProperty
(This->d_audio_converter,
kAudioConverterPropertyCalculateOutputBufferSize,
&prop_size,
&available_output_bytes);
check_error_and_throw
(err, "Get Output Buffer Size failed",
"audio_osx_source::au_input_callback");
UInt32 available_output_frames =
available_output_bytes / sizeof(float);
#if 0
// when decimating too much, the output sounds warbly due to
// fluctuating # of output frames
// This should not be a surprise, but there's probably some
// clever programming that could lessed the effect ...
// like finding the "ideal" # of output frames, and keeping
// that number constant no matter the # of input frames
UInt32 l_input_bytes = available_output_bytes;
prop_size = sizeof(available_output_bytes);
err = AudioConverterGetProperty
(This->d_audio_converter,
kAudioConverterPropertyCalculateInputBufferSize,
&prop_size, &l_input_bytes);
check_error_and_throw
(err, "Get Input Buffer Size failed",
"audio_osx_source::au_input_callback");
if(l_input_bytes < available_input_bytes) {
// OK to zero pad the input a little
++available_output_frames;
available_output_bytes = available_output_frames * sizeof(float);
}
#endif
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "cb1: avail: #IF = " << available_input_frames
<< ", #OF = " << available_output_frames << std::endl;
#endif
actual_output_frames = available_output_frames;
// convert the data to the correct rate; on input,
// actual_output_frames is the number of available output frames
err = AudioConverterFillComplexBuffer
(This->d_audio_converter,
reinterpret_cast<AudioConverterComplexInputDataProc>
(&(This->converter_callback)),
in_ref_con,
&actual_output_frames,
This->d_output_buffer,
NULL);
check_error_and_throw
(err, "AudioConverterFillComplexBuffer failed",
"audio_osx_source::au_input_callback");
// on output, actual_output_frames is the actual number of
// output frames
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "cb2: actual: #IF = " << This->d_n_actual_input_frames
<< ", #OF = " << actual_output_frames << std::endl;
if(This->d_n_actual_input_frames != available_input_frames)
std::cerr << "cb2.1: avail#IF = " << available_input_frames
<< ", actual#IF = " << This->d_n_actual_input_frames << std::endl;
#endif
}
// add the output frames to the buffers' queue, checking for overflow
int counter = This->d_n_user_channels;
int res = 0;
while(--counter >= 0) {
float* in_buffer = (float*)
This->d_output_buffer->mBuffers[counter].mData;
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "cb3: enqueuing audio data." << std::endl;
#endif
int l_res = This->d_buffers[counter]->enqueue
(in_buffer, actual_output_frames);
if(l_res == -1)
res = -1;
}
if(res == -1) {
// data coming in too fast
// drop oldest buffer
fputs("aO", stderr);
fflush(stderr);
// set the local number of samples available to the max
This->d_queue_sample_count =
This->d_buffers[0]->buffer_length_items();
}
else {
// keep up the local sample count
This->d_queue_sample_count += actual_output_frames;
}
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "cb4: #OI = " << actual_output_frames
<< ", #Cnt = " << This->d_queue_sample_count
<< ", mSC = " << This->d_buffer_sample_count << std::endl;
#endif
// signal that data is available, if appropraite
if (This->d_waiting_for_data) {
This->d_cond_data.notify_one();
}
#if _OSX_AU_DEBUG_RENDER_
std::cerr << "cb5: returning." << std::endl;
#endif
return(err);
}
#ifndef GR_USE_OLD_AUDIO_UNIT
OSStatus
osx_source::hardware_listener
(AudioObjectID in_object_id,
UInt32 in_num_addresses,
const AudioObjectPropertyAddress in_addresses[],
void* in_client_data)
#else
OSStatus
osx_source::hardware_listener
(AudioHardwarePropertyID in_property_id,
void* in_client_data)
#endif
{
osx_source* This = reinterpret_cast
<osx_source*>(in_client_data);
This->reset(true);
return(noErr);
}
#ifndef GR_USE_OLD_AUDIO_UNIT
OSStatus
osx_source::default_listener
(AudioObjectID in_object_id,
UInt32 in_num_addresses,
const AudioObjectPropertyAddress in_addresses[],
void* in_client_data)
#else
OSStatus
osx_source::default_listener
(AudioHardwarePropertyID in_property_id,
void* in_client_data)
#endif
{
osx_source* This = reinterpret_cast
<osx_source*>(in_client_data);
This->reset(false);
return(noErr);
}
} /* namespace audio */
} /* namespace gr */