ardour/livetrax
13
0
Fork 0
Code
8533b8244f
livetrax/libs/backends/wavesaudio/wavesapi/devicemanager/WCMRCoreAudioDeviceManager.cpp

3141 lines
105 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------------
//
// Copyright (c) 2008 Waves Audio Ltd. All rights reserved.
//
//! \file WCMRCoreAudioDeviceManager.cpp
//!
//! WCMRCoreAudioDeviceManager and related class declarations
//!
//---------------------------------------------------------------------------------*/
#include "WCMRCoreAudioDeviceManager.h"
#include <CoreServices/CoreServices.h>
#include "MiscUtils/safe_delete.h"
#include <sstream>
#include <syslog.h>
// This flag is turned to 1, but it does not work with aggregated devices.
// due to problems with aggregated devices this flag is not functional there
#define ENABLE_DEVICE_CHANGE_LISTNER 1
#define PROPERTY_CHANGE_SLEEP_TIME_MILLISECONDS 10
#define PROPERTY_CHANGE_TIMEOUT_SECONDS 5
#define USE_IOCYCLE_TIMES 1 ///< Set this to 0 to use individual thread cpu measurement
using namespace wvNS;
///< Supported Sample rates
static const double gAllSampleRates[] =
{
44100.0, 48000.0, 88200.0, 96000.0, 176400.0, 192000.0, -1 /* negative terminated list */
};
///< Default Supported Buffer Sizes.
static const int gAllBufferSizes[] =
{
32, 64, 96, 128, 192, 256, 512, 1024, 2048, -1 /* negative terminated list */
};
///< The default SR.
static const int DEFAULT_SR = 44100;
///< The default buffer size.
static const int DEFAULT_BUFFERSIZE = 1024;
static const int NONE_DEVICE_ID = -1;
///< Number of stalls to wait before notifying user...
static const int NUM_STALLS_FOR_NOTIFICATION = 2 * 50; // 2*50 corresponds to 2 * 50 x 42 ms idle timer - about 4 seconds.
static const int CHANGE_CHECK_COUNTER_PERIOD = 100; // 120 corresponds to 120 x 42 ms idle timer - about 4 seconds.
#define AUHAL_OUTPUT_ELEMENT 0
#define AUHAL_INPUT_ELEMENT 1
#include <sys/sysctl.h>
static int getProcessorCount()
{
int count = 1;
size_t size = sizeof(count);
if (sysctlbyname("hw.ncpu", &count, &size, NULL, 0))
return 1;
//if something did not work, let's revert to a safe value...
if (count == 0)
count = 1;
return count;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::WCMRCoreAudioDevice
//
//! Constructor for the audio device. Opens the PA device and gets information about the device.
//! such as determining supported sampling rates, buffer sizes, and channel counts.
//!
//! \param *pManager : The audio device manager that's managing this device.
//! \param deviceID : The port audio device ID.
//! \param useMultithreading : Whether to use multi-threading for audio processing. Default is true.
//!
//! \return Nothing.
//!
//**********************************************************************************************
WCMRCoreAudioDevice::WCMRCoreAudioDevice (WCMRCoreAudioDeviceManager *pManager, AudioDeviceID deviceID, bool useMultithreading, bool bNocopy)
: WCMRNativeAudioDevice (pManager, useMultithreading, bNocopy)
, m_SampleCountAtLastIdle (0)
, m_StalledSampleCounter(0)
, m_SampleCounter(0)
, m_BufferSizeChangeRequested (0)
, m_BufferSizeChangeReported (0)
, m_ResetRequested (0)
, m_ResetReported (0)
, m_ResyncRequested (0)
, m_ResyncReported (0)
, m_SRChangeRequested (0)
, m_SRChangeReported (0)
, m_ChangeCheckCounter(0)
, m_IOProcThreadPort (0)
, m_DropsDetected(0)
, m_DropsReported(0)
, m_IgnoreThisDrop(true)
, m_LastCPULog(0)
#if WV_USE_TONE_GEN
, m_pToneData(0)
, m_ToneDataSamples (0)
, m_NextSampleToUse (0)
#endif //WV_USE_TONE_GEN
{
AUTO_FUNC_DEBUG;
UInt32 propSize = 0;
OSStatus err = kAudioHardwareNoError;
//Update device info...
m_DeviceID = deviceID;
m_CurrentSamplingRate = DEFAULT_SR;
m_CurrentBufferSize = DEFAULT_BUFFERSIZE;
m_StopRequested = true;
m_pInputData = NULL;
m_CPUCount = getProcessorCount();
m_LastCPULog = wvThread::now() - 10 * wvThread::ktdOneSecond;
/*
@constant kAudioDevicePropertyNominalSampleRate
A Float64 that indicates the current nominal sample rate of the AudioDevice.
*/
Float64 currentNominalRate;
propSize = sizeof (currentNominalRate);
err = kAudioHardwareNoError;
if (AudioDeviceGetProperty(m_DeviceID, 0, 0, kAudioDevicePropertyNominalSampleRate, &propSize, &currentNominalRate) != kAudioHardwareNoError)
err = AudioDeviceGetProperty(m_DeviceID, 0, 1, kAudioDevicePropertyNominalSampleRate, &propSize, &currentNominalRate);
if (err == kAudioHardwareNoError)
m_CurrentSamplingRate = (int)currentNominalRate;
/*
@constant kAudioDevicePropertyBufferFrameSize
A UInt32 whose value indicates the number of frames in the IO buffers.
*/
UInt32 bufferSize;
propSize = sizeof (bufferSize);
err = kAudioHardwareNoError;
if (AudioDeviceGetProperty(m_DeviceID, 0, 0, kAudioDevicePropertyBufferFrameSize, &propSize, &bufferSize) != kAudioHardwareNoError)
err = AudioDeviceGetProperty(m_DeviceID, 0, 1, kAudioDevicePropertyBufferFrameSize, &propSize, &bufferSize);
if (err == kAudioHardwareNoError)
m_CurrentBufferSize = (int)bufferSize;
UpdateDeviceInfo();
//should use a valid current SR...
if (m_SamplingRates.size())
{
//see if the current sr is present in the sr list, if not, use the first one!
std::vector<int>::iterator intIter = find(m_SamplingRates.begin(), m_SamplingRates.end(), m_CurrentSamplingRate);
if (intIter == m_SamplingRates.end())
{
//not found... use the first one
m_CurrentSamplingRate = m_SamplingRates[0];
}
}
//should use a valid current buffer size
if (m_BufferSizes.size())
{
//see if the current sr is present in the buffersize list, if not, use the first one!
std::vector<int>::iterator intIter = find(m_BufferSizes.begin(), m_BufferSizes.end(), m_CurrentBufferSize);
if (intIter == m_BufferSizes.end())
{
//not found... use the first one
m_CurrentBufferSize = m_BufferSizes[0];
}
}
//build our input/output level lists
for (unsigned int currentChannel = 0; currentChannel < m_InputChannels.size(); currentChannel++)
{
m_InputLevels.push_back (0.0);
}
//build our input/output level lists
for (unsigned int currentChannel = 0; currentChannel < m_OutputChannels.size(); currentChannel++)
{
m_OutputLevels.push_back (0.0);
}
}
//**********************************************************************************************
// WCMRCoreAudioDevice::~WCMRCoreAudioDevice
//
//! Destructor for the audio device. The base release all the connections that were created, if
//! they have not been already destroyed! Here we simply stop streaming, and close device
//! handles if necessary.
//!
//! \param none
//!
//! \return Nothing.
//!
//**********************************************************************************************
WCMRCoreAudioDevice::~WCMRCoreAudioDevice ()
{
AUTO_FUNC_DEBUG;
try
{
//If device is streaming, need to stop it!
if (Streaming())
{
SetStreaming (false);
}
//If device is active (meaning stream is open) we need to close it.
if (Active())
{
SetActive (false);
}
}
catch (...)
{
//destructors should absorb exceptions, no harm in logging though!!
DEBUG_MSG ("Exception during destructor");
}
}
//**********************************************************************************************
// WCMRCoreAudioDevice::UpdateDeviceInfo
//
//! Updates Device Information about channels, sampling rates, buffer sizes.
//!
//! \return WTErr.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::UpdateDeviceInfo ()
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
// Some devices change the ID during restart
WTErr errId = UpdateDeviceId();
// Update all devices parts regardless of errors
WTErr errName = UpdateDeviceName();
WTErr errIn = UpdateDeviceInputs();
WTErr errOut = UpdateDeviceOutputs();
WTErr errSR = eNoErr;
WTErr errBS = eNoErr;
errSR = UpdateDeviceSampleRates();
errBS = UpdateDeviceBufferSizes();
if(errId != eNoErr || errName != eNoErr || errIn != eNoErr || errOut != eNoErr || errSR != eNoErr || errBS != eNoErr)
{
retVal = eCoreAudioFailed;
}
return retVal;
}
WTErr WCMRCoreAudioDevice::UpdateDeviceId()
{
//Get device count...
UInt32 propSize = 0;
WTErr retVal = eNoErr;
OSStatus osErr = AudioHardwareGetPropertyInfo (kAudioHardwarePropertyDevices, &propSize, NULL);
ASSERT_ERROR(osErr, "AudioHardwareGetProperty 1");
if (WUIsError(osErr))
throw osErr;
size_t numDevices = propSize / sizeof (AudioDeviceID);
AudioDeviceID* deviceIDs = new AudioDeviceID[numDevices];
//retrieve the device IDs
propSize = numDevices * sizeof (AudioDeviceID);
osErr = AudioHardwareGetProperty (kAudioHardwarePropertyDevices, &propSize, deviceIDs);
ASSERT_ERROR(osErr, "Error while getting audio devices: AudioHardwareGetProperty 2");
if (WUIsError(osErr))
throw osErr;
//now add the ones that are not there...
for (size_t deviceIndex = 0; deviceIndex < numDevices; deviceIndex++)
{
DeviceInfo* pDevInfo = 0;
//Get device name and create new DeviceInfo entry
//Get property name size.
osErr = AudioDeviceGetPropertyInfo(deviceIDs[deviceIndex], 0, 0, kAudioDevicePropertyDeviceName, &propSize, NULL);
if (osErr == kAudioHardwareNoError)
{
//Get property: name.
char* deviceName = new char[propSize];
osErr = AudioDeviceGetProperty(deviceIDs[deviceIndex], 0, 0, kAudioDevicePropertyDeviceName, &propSize, deviceName);
if (osErr == kAudioHardwareNoError)
{
if ( (m_DeviceName == deviceName) &&
(m_DeviceID != deviceIDs[deviceIndex]) ) {
m_DeviceID = deviceIDs[deviceIndex];
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceDebugInfo, (void *)"Current device has changed it's id.");
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device name. Device ID: " << m_DeviceID);
}
delete [] deviceName;
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device name prop Info. Device ID: " << m_DeviceID);
}
}
delete [] deviceIDs;
return retVal;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::UpdateDeviceName
//
//! Updates Device name.
//!
//! Use 'kAudioDevicePropertyDeviceName'
//!
//! 1. Get property name size.
//! 2. Get property: name.
//!
//! \return WTErr.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::UpdateDeviceName()
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 propSize = 0;
// Initiate name to unknown.
m_DeviceName = "Unknown";
//! 1. Get property name size.
err = AudioDeviceGetPropertyInfo(m_DeviceID, 0, 0, kAudioDevicePropertyDeviceName, &propSize, NULL);
if (err == kAudioHardwareNoError)
{
//! 2. Get property: name.
char* deviceName = new char[propSize];
err = AudioDeviceGetProperty(m_DeviceID, 0, 0, kAudioDevicePropertyDeviceName, &propSize, deviceName);
if (err == kAudioHardwareNoError)
{
m_DeviceName = deviceName;
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device name. Device ID: " << m_DeviceID);
}
delete [] deviceName;
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device name property size. Device ID: " << m_DeviceID);
}
return retVal;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::UpdateDeviceInputs
//
//! Updates Device Inputs.
//!
//! Use 'kAudioDevicePropertyStreamConfiguration'
//! This property returns the stream configuration of the device in an
//! AudioBufferList (with the buffer pointers set to NULL) which describes the
//! list of streams and the number of channels in each stream. This corresponds
//! to what will be passed into the IOProc.
//!
//! 1. Get property cannels input size.
//! 2. Get property: cannels input.
//! 3. Update input channels
//!
//! \return WTErr.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::UpdateDeviceInputs()
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 propSize = 0;
int maxInputChannels = 0;
// 1. Get property cannels input size.
err = AudioDeviceGetPropertyInfo (m_DeviceID, 0, 1/* Input */, kAudioDevicePropertyStreamConfiguration, &propSize, NULL);
if (err == kAudioHardwareNoError)
{
//! 2. Get property: cannels input.
// Allocate size according to the property size. Note that this is a variable sized struct...
AudioBufferList *pStreamBuffers = (AudioBufferList *)malloc(propSize);
if (pStreamBuffers)
{
memset (pStreamBuffers, 0, propSize);
// Get the Input channels
err = AudioDeviceGetProperty (m_DeviceID, 0, true/* Input */, kAudioDevicePropertyStreamConfiguration, &propSize, pStreamBuffers);
if (err == kAudioHardwareNoError)
{
// Calculate the number of input channels
for (UInt32 streamIndex = 0; streamIndex < pStreamBuffers->mNumberBuffers; streamIndex++)
{
maxInputChannels += pStreamBuffers->mBuffers[streamIndex].mNumberChannels;
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Input channels. Device Name: " << m_DeviceName.c_str());
}
free (pStreamBuffers);
}
else
{
retVal = eMemOutOfMemory;
DEBUG_MSG("Faild to allocate memory. Device Name: " << m_DeviceName.c_str());
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Input channels property size. Device Name: " << m_DeviceName.c_str());
}
// Update input channels
m_InputChannels.clear();
for (int channel = 0; channel < maxInputChannels; channel++)
{
CFStringRef cfName;
std::stringstream chNameStream;
UInt32 nameSize = 0;
OSStatus error = kAudioHardwareNoError;
error = AudioDeviceGetPropertyInfo (m_DeviceID,
channel + 1,
true /* Input */,
kAudioDevicePropertyChannelNameCFString,
&nameSize,
NULL);
if (error == kAudioHardwareNoError)
{
error = AudioDeviceGetProperty (m_DeviceID,
channel + 1,
true /* Input */,
kAudioDevicePropertyChannelNameCFString,
&nameSize,
&cfName);
}
bool decoded = false;
char* cstr_name = 0;
if (error == kAudioHardwareNoError)
{
CFIndex length = CFStringGetLength(cfName);
CFIndex maxSize = CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8);
cstr_name = new char[maxSize];
decoded = CFStringGetCString(cfName, cstr_name, maxSize, kCFStringEncodingUTF8);
}
chNameStream << (channel+1) << " - ";
if (cstr_name && decoded && (0 != std::strlen(cstr_name) ) ) {
chNameStream << cstr_name;
}
else
{
chNameStream << "Input " << (channel+1);
}
m_InputChannels.push_back (chNameStream.str());
delete [] cstr_name;
}
return retVal;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::UpdateDeviceOutputs
//
//! Updates Device Outputs.
//!
//! Use 'kAudioDevicePropertyStreamConfiguration'
//! This property returns the stream configuration of the device in an
//! AudioBufferList (with the buffer pointers set to NULL) which describes the
//! list of streams and the number of channels in each stream. This corresponds
//! to what will be passed into the IOProc.
//!
//! 1. Get property cannels output size.
//! 2. Get property: cannels output.
//! 3. Update output channels
//!
//! \return Nothing.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::UpdateDeviceOutputs()
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 propSize = 0;
int maxOutputChannels = 0;
//! 1. Get property cannels output size.
err = AudioDeviceGetPropertyInfo (m_DeviceID, 0, 0/* Output */, kAudioDevicePropertyStreamConfiguration, &propSize, NULL);
if (err == kAudioHardwareNoError)
{
//! 2. Get property: cannels output.
// Allocate size according to the property size. Note that this is a variable sized struct...
AudioBufferList *pStreamBuffers = (AudioBufferList *)malloc(propSize);
if (pStreamBuffers)
{
memset (pStreamBuffers, 0, propSize);
// Get the Output channels
err = AudioDeviceGetProperty (m_DeviceID, 0, 0/* Output */, kAudioDevicePropertyStreamConfiguration, &propSize, pStreamBuffers);
if (err == kAudioHardwareNoError)
{
// Calculate the number of output channels
for (UInt32 streamIndex = 0; streamIndex < pStreamBuffers->mNumberBuffers; streamIndex++)
{
maxOutputChannels += pStreamBuffers->mBuffers[streamIndex].mNumberChannels;
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Output channels. Device Name: " << m_DeviceName.c_str());
}
free (pStreamBuffers);
}
else
{
retVal = eMemOutOfMemory;
DEBUG_MSG("Faild to allocate memory. Device Name: " << m_DeviceName.c_str());
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Output channels property size. Device Name: " << m_DeviceName.c_str());
}
// Update output channels
m_OutputChannels.clear();
for (int channel = 0; channel < maxOutputChannels; channel++)
{
CFStringRef cfName;
std::stringstream chNameStream;
UInt32 nameSize = 0;
OSStatus error = kAudioHardwareNoError;
error = AudioDeviceGetPropertyInfo (m_DeviceID,
channel + 1,
false /* Output */,
kAudioDevicePropertyChannelNameCFString,
&nameSize,
NULL);
if (error == kAudioHardwareNoError)
{
error = AudioDeviceGetProperty (m_DeviceID,
channel + 1,
false /* Output */,
kAudioDevicePropertyChannelNameCFString,
&nameSize,
&cfName);
}
bool decoded = false;
char* cstr_name = 0;
if (error == kAudioHardwareNoError )
{
CFIndex length = CFStringGetLength(cfName);
CFIndex maxSize = CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8);
cstr_name = new char[maxSize];
decoded = CFStringGetCString(cfName, cstr_name, maxSize, kCFStringEncodingUTF8);
}
chNameStream << (channel+1) << " - ";
if (cstr_name && decoded && (0 != std::strlen(cstr_name) ) ) {
chNameStream << cstr_name;
}
else
{
chNameStream << "Output " << (channel+1);
}
m_OutputChannels.push_back (chNameStream.str());
delete [] cstr_name;
}
return retVal;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::UpdateDeviceSampleRates
//
//! Updates Device Sample rates.
//!
//! Use 'kAudioDevicePropertyAvailableNominalSampleRates'
//!
//! 1. Get sample rate property size.
//! 2. Get property: sample rates.
//! 3. Update sample rates
//!
//! \return Nothing.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::UpdateDeviceSampleRates()
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 propSize = 0;
m_SamplingRates.clear();
//! 1. Get sample rate property size.
err = AudioDeviceGetPropertyInfo(m_DeviceID, 0, 0, kAudioDevicePropertyAvailableNominalSampleRates, &propSize, NULL);
if (err == kAudioHardwareNoError)
{
//! 2. Get property: cannels output.
// Allocate size accrding to the number of audio values
int numRates = propSize / sizeof(AudioValueRange);
AudioValueRange* supportedRates = new AudioValueRange[numRates];
// Get sampling rates from Audio device
err = AudioDeviceGetProperty(m_DeviceID, 0, 0, kAudioDevicePropertyAvailableNominalSampleRates, &propSize, supportedRates);
if (err == kAudioHardwareNoError)
{
//! 3. Update sample rates
// now iterate through our standard SRs
for(int ourSR=0; gAllSampleRates[ourSR] > 0; ourSR++)
{
//check to see if our SR is in the supported rates...
for (int deviceSR = 0; deviceSR < numRates; deviceSR++)
{
if ((supportedRates[deviceSR].mMinimum <= gAllSampleRates[ourSR]) &&
(supportedRates[deviceSR].mMaximum >= gAllSampleRates[ourSR]))
{
m_SamplingRates.push_back ((int)gAllSampleRates[ourSR]);
break;
}
}
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Sample rates. Device Name: " << m_DeviceName.c_str());
}
delete [] supportedRates;
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Sample rates property size. Device Name: " << m_DeviceName.c_str());
}
return retVal;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::UpdateDeviceBufferSizes_Simple
//
// Use kAudioDevicePropertyBufferFrameSizeRange
//
// in case of 'eMatchedDuplexDevices' and a matching device exists return common device name
// in all other cases retur base class function implementation
//
// 1. Get buffer size range
// 2. Run on all ranges and add them to the list
//
// \return error code
//
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::UpdateDeviceBufferSizes ()
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 propSize = 0;
// Clear buffer sizes
m_BufferSizes.clear();
// 1. Get buffer size range
AudioValueRange bufferSizesRange;
propSize = sizeof (AudioValueRange);
err = AudioDeviceGetProperty (m_DeviceID, 0, 0, kAudioDevicePropertyBufferFrameSizeRange, &propSize, &bufferSizesRange);
if(err == kAudioHardwareNoError)
{
// 2. Run on all ranges and add them to the list
for(int bsize=0; gAllBufferSizes[bsize] > 0; bsize++)
{
if ((bufferSizesRange.mMinimum <= gAllBufferSizes[bsize]) && (bufferSizesRange.mMaximum >= gAllBufferSizes[bsize]))
{
m_BufferSizes.push_back (gAllBufferSizes[bsize]);
}
}
//if we didn't get a single hit, let's simply add the min. and the max...
if (m_BufferSizes.empty())
{
m_BufferSizes.push_back ((int)bufferSizesRange.mMinimum);
m_BufferSizes.push_back ((int)bufferSizesRange.mMaximum);
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device buffer sizes range. Device Name: " << m_DeviceName.c_str());
}
return retVal;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::DeviceName
//
//! in case of 'eMatchedDuplexDevices' and a matching device exists return common device name
//! in all other cases retur base class function implementation
//!
//! \param none
//!
//! \return current device name
//!
//**********************************************************************************************
const std::string& WCMRCoreAudioDevice::DeviceName() const
{
return WCMRAudioDevice::DeviceName();
}
//**********************************************************************************************
// WCMRCoreAudioDevice::InputChannels
//
//! return base class function implementation
//!
//! \param none
//!
//! \return base class function implementation
//!
//**********************************************************************************************
const std::vector<std::string>& WCMRCoreAudioDevice::InputChannels()
{
return WCMRAudioDevice::InputChannels();
}
//**********************************************************************************************
// WCMRCoreAudioDevice::OutputChannels
//
//! in case of 'eMatchedDuplexDevices' return matching device output channel if there is one
//! in all other cases retur base class function implementation
//!
//! \param none
//!
//! \return list of output channels of current device
//!
//**********************************************************************************************
const std::vector<std::string>& WCMRCoreAudioDevice::OutputChannels()
{
return WCMRAudioDevice::OutputChannels();
}
//**********************************************************************************************
// WCMRCoreAudioDevice::SamplingRates
//
//! in case of 'eMatchedDuplexDevices' and a matching device exists return common sample rate
//! in all other cases retur base class function implementation
//!
//! \param none
//!
//! \return current sample rate
//!
//**********************************************************************************************
const std::vector<int>& WCMRCoreAudioDevice::SamplingRates()
{
return WCMRAudioDevice::SamplingRates();
}
//**********************************************************************************************
// WCMRCoreAudioDevice::CurrentSamplingRate
//
//! The device's current sampling rate. This may be overridden, if the device needs to
//! query the driver for the current rate.
//!
//! \param none
//!
//! \return The device's current sampling rate. -1 on error.
//!
//**********************************************************************************************
int WCMRCoreAudioDevice::CurrentSamplingRate ()
{
AUTO_FUNC_DEBUG;
//ToDo: Perhaps for ASIO devices that are active, we should retrive the SR from the device...
UInt32 propSize = 0;
OSStatus err = kAudioHardwareNoError;
Float64 currentNominalRate;
propSize = sizeof (currentNominalRate);
err = kAudioHardwareNoError;
if (AudioDeviceGetProperty(m_DeviceID, 0, 0, kAudioDevicePropertyNominalSampleRate, &propSize, &currentNominalRate) != kAudioHardwareNoError)
err = AudioDeviceGetProperty(m_DeviceID, 0, 1, kAudioDevicePropertyNominalSampleRate, &propSize, &currentNominalRate);
if (err == kAudioHardwareNoError)
m_CurrentSamplingRate = (int)currentNominalRate;
else
{
DEBUG_MSG("Unable to get sampling rate!");
}
return (m_CurrentSamplingRate);
}
//**********************************************************************************************
// WCMRCoreAudioDevice::SetCurrentSamplingRate
//
//! Change the sampling rate to be used by the device.
//!
//! \param newRate : The rate to use (samples per sec).
//!
//! \return eNoErr always. The derived classes may return error codes.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::SetCurrentSamplingRate (int newRate)
{
AUTO_FUNC_DEBUG;
std::vector<int>::iterator intIter;
WTErr retVal = eNoErr;
//changes the status.
int oldRate = CurrentSamplingRate();
bool oldActive = Active();
//no change, nothing to do
if (oldRate == newRate)
goto Exit;
//see if this is one of our supported rates...
intIter = find(m_SamplingRates.begin(), m_SamplingRates.end(), newRate);
if (intIter == m_SamplingRates.end())
{
//Can't change, perhaps use an "invalid param" type of error
retVal = eCommandLineParameter;
goto Exit;
}
if (Streaming())
{
//Can't change, perhaps use an "in use" type of error
retVal = eGenericErr;
goto Exit;
}
if (oldActive)
{
//Deactivate it for the change...
SetActive (false);
}
retVal = SetAndCheckCurrentSamplingRate (newRate);
if(retVal == eNoErr)
{
retVal = UpdateDeviceInfo ();
}
//reactivate it.
if (oldActive)
{
retVal = SetActive (true);
}
Exit:
return (retVal);
}
//**********************************************************************************************
// WCMRCoreAudioDevice::SetAndCheckCurrentSamplingRate
//
//! Change the sampling rate to be used by the device.
//!
//! \param newRate : The rate to use (samples per sec).
//!
//! \return eNoErr always. The derived classes may return error codes.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::SetAndCheckCurrentSamplingRate (int newRate)
{
AUTO_FUNC_DEBUG;
std::vector<int>::iterator intIter;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 propSize = 0;
// 1. Set new sampling rate
Float64 newNominalRate = newRate;
propSize = sizeof (Float64);
err = AudioDeviceSetProperty(m_DeviceID, NULL, 0, 0, kAudioDevicePropertyNominalSampleRate, propSize, &newNominalRate);
if (err != kAudioHardwareNoError)
{
retVal = eCoreAudioFailed;
DEBUG_MSG ("Unable to set SR! Device name: " << m_DeviceName.c_str());
}
else
{
// 2. wait for the SR to actually change...
// Set total time out time
int tryAgain = ((PROPERTY_CHANGE_TIMEOUT_SECONDS * 1000) / PROPERTY_CHANGE_SLEEP_TIME_MILLISECONDS) ;
int actualWait = 0;
Float64 actualSamplingRate = 0.0;
// Run as ling as time out is not finished
while (tryAgain)
{
// Get current sampling rate
err = AudioDeviceGetProperty(m_DeviceID, 0, 0, kAudioDevicePropertyNominalSampleRate, &propSize, &actualSamplingRate);
if (err == kAudioHardwareNoError)
{
if (actualSamplingRate == newNominalRate)
{
//success, let's get out!
break;
}
}
else
{
//error reading rate, but let's not complain too much!
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceDebugInfo, (void *)"Could not read Sampling Rate for verification.");
DEBUG_MSG ("Unable to get SR. Device name: " << m_DeviceName.c_str());
}
// oh well...there's always another millisecond...
wvThread::sleep_milliseconds (PROPERTY_CHANGE_SLEEP_TIME_MILLISECONDS);
tryAgain--;
actualWait++;
}
// If sample rate actually changed
if (tryAgain != 0)
{
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceDebugInfo, (void *)"Changed the Sampling Rate.");
// Update member with new rate
m_CurrentSamplingRate = newRate;
char debugMsg[128];
snprintf (debugMsg, sizeof(debugMsg), "Actual Wait for SR Change was %d milliseconds", actualWait * PROPERTY_CHANGE_SLEEP_TIME_MILLISECONDS);
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceDebugInfo, (void *)debugMsg);
}
// If sample rate did not change after time out
else
{
// Check if current device sample rate is supported
bool found = false;
for(int i = 0; gAllSampleRates[i] > 0; i++)
{
if (fabs(gAllSampleRates[i] - actualSamplingRate) < 0.01) {
found = true;
}
}
if (found) {
// Update member with last read value
m_CurrentSamplingRate = static_cast<int>(actualSamplingRate);
char debugMsg[128];
snprintf (debugMsg, sizeof(debugMsg), "Unable to change SR, even after waiting for %d milliseconds", actualWait * PROPERTY_CHANGE_SLEEP_TIME_MILLISECONDS);
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceDebugInfo, (void *)debugMsg);
float sample_rate_update = actualSamplingRate;
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::SamplingRateChanged, (void *)&sample_rate_update);
} else {
retVal = eGenericErr;
}
}
}
return (retVal);
}
//**********************************************************************************************
// WCMRCoreAudioDevice::BufferSizes
//
//! in case of 'eMatchedDuplexDevices' and a matching device exists return common buffer sizes
//! in all other cases retur base class function implementation
//!
//! \param none
//!
//! \return current sample rate
//!
//**********************************************************************************************
const std::vector<int>& WCMRCoreAudioDevice::BufferSizes()
{
return WCMRAudioDevice::BufferSizes();
}
//**********************************************************************************************
// WCMRCoreAudioDevice::CurrentBufferSize
//
//! The device's current buffer size in use. This may be overridden, if the device needs to
//! query the driver for the current size.
//!
//! \param none
//!
//! \return The device's current buffer size. 0 on error.
//!
//**********************************************************************************************
int WCMRCoreAudioDevice::CurrentBufferSize ()
{
AUTO_FUNC_DEBUG;
return (m_CurrentBufferSize);
}
//**********************************************************************************************
// WCMRCoreAudioDevice::SetCurrentBufferSize
//
//! Change the buffer size to be used by the device. This will most likely be overridden,
//! the base class simply updates the member variable.
//!
//! \param newSize : The buffer size to use (in sample-frames)
//!
//! \return eNoErr always. The derived classes may return error codes.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::SetCurrentBufferSize (int newSize)
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
std::vector<int>::iterator intIter;
//changes the status.
int oldSize = CurrentBufferSize();
bool oldActive = Active();
//same size, nothing to do.
if (oldSize == newSize)
goto Exit;
if (Streaming())
{
//Can't change, perhaps use an "in use" type of error
retVal = eGenericErr;
goto Exit;
}
if (oldActive)
{
//Deactivate it for the change...
SetActive (false);
}
// when audio device is inactive it is safe to set a working buffer size according to new buffer size
// if 'newSize' is not a valid buffer size, another valid buffer size will be set
retVal = SetWorkingBufferSize(newSize);
if(retVal != eNoErr)
{
DEBUG_MSG("Unable to set a working buffer size. Device Name: " << DeviceName().c_str());
goto Exit;
}
//reactivate it.
if (oldActive)
{
retVal = SetActive (true);
if(retVal != eNoErr)
{
DEBUG_MSG("Unable to activate device. Device Name: " << DeviceName().c_str());
goto Exit;
}
}
Exit:
return (retVal);
}
WTErr WCMRCoreAudioDevice::SetWorkingBufferSize(int newSize)
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
// 1. Set new buffer size
err = SetBufferSizesByIO(newSize);
// If there's no error it means this buffer size is supported
if(err == kAudioHardwareNoError)
{
m_CurrentBufferSize = newSize;
}
// If there was an error it means that this buffer size was not supported
else
{
// In case the new buffer size could not be set, set another working buffer size
// Run on all buffer sizes:
// Try setting buffer sizes that are bigger then selected buffer size first,
// Since bigger buffer sizes usually work safer
for(std::vector<int>::const_iterator iter = m_BufferSizes.begin();iter != m_BufferSizes.end();++iter)
{
int nCurBS = *iter;
if(nCurBS > newSize)
{
// Try setting current buffer size
err = SetBufferSizesByIO(nCurBS);
// in case buffer size is valid
if(err == kAudioHardwareNoError)
{
// Set current buffer size
m_CurrentBufferSize = nCurBS;
break;
}
}
}
// If bigger buffer sizes failed, go to smaller buffer sizes
if(err != kAudioHardwareNoError)
{
for(std::vector<int>::const_iterator iter = m_BufferSizes.begin();iter != m_BufferSizes.end();++iter)
{
int nCurBS = *iter;
if(nCurBS < newSize)
{
// Try setting current buffer size
err = SetBufferSizesByIO(*iter);
// in case buffer size is valid
if(err == kAudioHardwareNoError)
{
// Set current buffer size
m_CurrentBufferSize = *iter;
break;
}
}
}
}
// Check if a valid buffer size was found
if(err == kAudioHardwareNoError)
{
// Notify that a different sample rate is set
char debugMsg[256];
snprintf (debugMsg, sizeof(debugMsg), "Could not set buffer size: %d, Set buffer size to: %d.", newSize, m_CurrentBufferSize);
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceDebugInfo, (void *)debugMsg);
}
// if there was no buffer size that could be set
else
{
// Set the parameter buffer size by default, set a debug message
m_CurrentBufferSize = newSize;
DEBUG_MSG("Unable to set any buffer size. Device Name: " << m_DeviceName.c_str());
}
}
return retVal;
}
OSStatus WCMRCoreAudioDevice::SetBufferSizesByIO(int newSize)
{
OSStatus err = kAudioHardwareNoError;
// 1. Set new buffer size
UInt32 bufferSize = (UInt32)newSize;
UInt32 propSize = sizeof (UInt32);
// Set new buffer size to input
if (!m_InputChannels.empty())
{
err = AudioDeviceSetProperty(m_DeviceID, NULL, 0, 1, kAudioDevicePropertyBufferFrameSize, propSize, &bufferSize);
}
else
{
err = AudioDeviceSetProperty(m_DeviceID, NULL, 0, 0, kAudioDevicePropertyBufferFrameSize, propSize, &bufferSize);
}
return err;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::ConnectionStatus
//
//! Retrieves the device's current connection status. This will most likely be overridden,
//! in case some driver communication is required to query the status.
//!
//! \param none
//!
//! \return A ConnectionStates value.
//!
//**********************************************************************************************
WCMRCoreAudioDevice::ConnectionStates WCMRCoreAudioDevice::ConnectionStatus ()
{
AUTO_FUNC_DEBUG;
//ToDo: May want to do something more to extract the actual status!
return (m_ConnectionStatus);
}
//**********************************************************************************************
// WCMRCoreAudioDevice::EnableAudioUnitIO
//
//! Sets up the AUHAL for IO, allowing changes to the devices to be used by the AudioUnit.
//!
//! \param none
//!
//! \return eNoErr on success, an error code on failure.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::EnableAudioUnitIO()
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 enableIO = 1;
if (!m_InputChannels.empty())
{
///////////////
//ENABLE IO (INPUT)
//You must enable the Audio Unit (AUHAL) for input
//Enable input on the AUHAL
err = AudioUnitSetProperty(m_AUHALAudioUnit,
kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input,
AUHAL_INPUT_ELEMENT,
&enableIO, sizeof(enableIO));
if (err)
{
DEBUG_MSG("Couldn't Enable IO on input scope of input element, error = " << err);
retVal = eGenericErr;
goto Exit;
}
}
//disable Output on the AUHAL if there's no output
if (m_OutputChannels.empty())
enableIO = 0;
else
enableIO = 1;
err = AudioUnitSetProperty(m_AUHALAudioUnit,
kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output,
AUHAL_OUTPUT_ELEMENT,
&enableIO, sizeof(enableIO));
if (err)
{
DEBUG_MSG("Couldn't Enable/Disable IO on output scope of output element, error = " << err);
retVal = eGenericErr;
goto Exit;
}
Exit:
return retVal;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::EnableListeners
//
//! Sets up listeners to listen for Audio Device property changes, so that app can be notified.
//!
//! \param none
//!
//! \return eNoErr on success, an error code on failure.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::EnableListeners()
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
//listner for SR change...
err = AudioDeviceAddPropertyListener(m_DeviceID, 0, 0, kAudioDevicePropertyNominalSampleRate,
StaticPropertyChangeProc, this);
if (err)
{
DEBUG_MSG("Couldn't Setup SR Property Listner, error = " << err);
retVal = eGenericErr;
goto Exit;
}
#if ENABLE_DEVICE_CHANGE_LISTNER
{
//listner for device change...
err = AudioDeviceAddPropertyListener (m_DeviceID,
kAudioPropertyWildcardChannel,
true,
kAudioDevicePropertyDeviceHasChanged,
StaticPropertyChangeProc,
this);
if (err)
{
DEBUG_MSG("Couldn't Setup device change Property Listner, error = " << err);
retVal = eGenericErr;
goto Exit;
}
}
#endif //ENABLE_DEVICE_CHANGE_LISTNER
//listner for dropouts...
err = AudioDeviceAddPropertyListener(m_DeviceID, 0, 0, kAudioDeviceProcessorOverload,
StaticPropertyChangeProc, this);
if (err)
{
DEBUG_MSG("Couldn't Setup Processor Overload Property Listner, error = " << err);
retVal = eGenericErr;
goto Exit;
}
Exit:
return retVal;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::DisableListeners
//
//! Undoes the work done by EnableListeners
//!
//! \param none
//!
//! \return eNoErr on success, an error code on failure.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::DisableListeners()
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
//listner for SR change...
err = AudioDeviceRemovePropertyListener(m_DeviceID, 0, 0, kAudioDevicePropertyNominalSampleRate,
StaticPropertyChangeProc);
if (err)
{
DEBUG_MSG("Couldn't Cleanup SR Property Listner, error = " << err);
//not sure if we need to report this...
}
#if ENABLE_DEVICE_CHANGE_LISTNER
{
err = AudioDeviceRemovePropertyListener (m_DeviceID,
kAudioPropertyWildcardChannel,
true/* Input */,
kAudioDevicePropertyDeviceHasChanged,
StaticPropertyChangeProc);
if (err)
{
DEBUG_MSG("Couldn't Cleanup device input stream change Property Listner, error = " << err);
//not sure if we need to report this...
}
}
#endif //ENABLE_DEVICE_CHANGE_LISTNER
err = AudioDeviceRemovePropertyListener(m_DeviceID, 0, 0, kAudioDeviceProcessorOverload,
StaticPropertyChangeProc);
if (err)
{
DEBUG_MSG("Couldn't Cleanup device change Property Listner, error = " << err);
//not sure if we need to report this...
}
return retVal;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::StaticPropertyChangeProc
//
//! The property change function called (as a result of EnableListeners) when device properties change.
//! It calls upon the non-static PropertyChangeProc to do the work.
//!
//! \param inDevice : The audio device in question.
//! \param inChannel : The channel on which the property has change.
//! \param isInput : If the change is for Input.
//! \param inPropertyID : The property that has changed.
//! \param inClientData: What was passed when listener was enabled, in our case teh WCMRCoreAudioDevice object.
//!
//! \return 0 always.
//!
//**********************************************************************************************
OSStatus WCMRCoreAudioDevice::StaticPropertyChangeProc (AudioDeviceID /*inDevice*/, UInt32 /*inChannel*/, Boolean /*isInput*/,
AudioDevicePropertyID inPropertyID, void *inClientData)
{
if (inClientData)
{
WCMRCoreAudioDevice* pCoreDevice = (WCMRCoreAudioDevice *)inClientData;
pCoreDevice->PropertyChangeProc (inPropertyID);
}
return 0;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::PropertyChangeProc
//
//! The non-static property change proc. Gets called when properties change. Since this gets called
//! on an arbitrary thread, we simply update the request counters and return.
//!
//! \param none
//!
//! \return nothing.
//!
//**********************************************************************************************
void WCMRCoreAudioDevice::PropertyChangeProc (AudioDevicePropertyID inPropertyID)
{
switch (inPropertyID)
{
case kAudioDevicePropertyNominalSampleRate:
m_SRChangeRequested++;
break;
#if ENABLE_DEVICE_CHANGE_LISTNER
case kAudioDevicePropertyDeviceHasChanged:
{
m_ResetRequested++;
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::RequestReset);
}
break;
#endif //ENABLE_DEVICE_CHANGE_LISTNER
case kAudioDeviceProcessorOverload:
{
if (m_IgnoreThisDrop)
m_IgnoreThisDrop = false; //We'll ignore once, just once!
else
m_DropsDetected++;
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::Dropout );
break;
}
default:
break;
}
}
//**********************************************************************************************
// WCMRCoreAudioDevice::SetupAUHAL
//
//! Sets up the AUHAL AudioUnit for device IO.
//!
//! \param none
//!
//! \return eNoErr on success, an error code on failure.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::SetupAUHAL()
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 propSize = 0;
Component comp;
ComponentDescription desc;
AudioStreamBasicDescription streamFormatToUse, auhalStreamFormat;
//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_HALOutput;
//all Audio Units in AUComponent.h must use
//"kAudioUnitManufacturer_Apple" as the Manufacturer
desc.componentManufacturer = kAudioUnitManufacturer_Apple;
desc.componentFlags = 0;
desc.componentFlagsMask = 0;
//Finds a component that meets the desc spec's
comp = FindNextComponent(NULL, &desc);
if (comp == NULL)
{
DEBUG_MSG("Couldn't find AUHAL Component");
retVal = eGenericErr;
goto Exit;
}
//gains access to the services provided by the component
OpenAComponent(comp, &m_AUHALAudioUnit);
retVal = EnableAudioUnitIO();
if (retVal != eNoErr)
goto Exit;
//Now setup the device to use by the audio unit...
//input
if (!m_InputChannels.empty())
{
err = AudioUnitSetProperty(m_AUHALAudioUnit, kAudioOutputUnitProperty_CurrentDevice,
kAudioUnitScope_Global, AUHAL_INPUT_ELEMENT,
&m_DeviceID, sizeof(m_DeviceID));
if (err)
{
DEBUG_MSG("Couldn't Set the audio device property for Input Element Global scope, error = " << err);
retVal = eGenericErr;
goto Exit;
}
}
//output
if (!m_OutputChannels.empty())
{
err = AudioUnitSetProperty(m_AUHALAudioUnit, kAudioOutputUnitProperty_CurrentDevice,
kAudioUnitScope_Global, AUHAL_OUTPUT_ELEMENT,
&m_DeviceID, sizeof(m_DeviceID));
if (err)
{
DEBUG_MSG("Couldn't Set the audio device property for Output Element Global scope, error = " << err);
retVal = eGenericErr;
goto Exit;
}
}
//also set Sample Rate...
{
retVal = SetAndCheckCurrentSamplingRate(m_CurrentSamplingRate);
if(retVal != eNoErr)
{
DEBUG_MSG ("Unable to set SR, error = " << err);
goto Exit;
}
}
//now set the buffer size...
{
err = SetWorkingBufferSize(m_CurrentBufferSize);
if (err)
{
DEBUG_MSG("Couldn't Set the buffer size property, error = " << err);
//we don't really quit here..., just keep going even if this does not work,
//the AUHAL is supposed to take care of this by way of slicing...
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceDebugInfo, (void *)"Could not set buffer size.");
}
}
//convertor quality
{
UInt32 quality = kAudioConverterQuality_Max;
propSize = sizeof (quality);
err = AudioUnitSetProperty(m_AUHALAudioUnit,
kAudioUnitProperty_RenderQuality, kAudioUnitScope_Global,
AUHAL_OUTPUT_ELEMENT,
&quality, sizeof (quality));
if (err != kAudioHardwareNoError)
{
DEBUG_MSG ("Unable to set Convertor Quality, error = " << err);
retVal = eGenericErr;
goto Exit;
}
}
memset (&auhalStreamFormat, 0, sizeof (auhalStreamFormat));
propSize = sizeof (auhalStreamFormat);
err = AudioUnitGetProperty(m_AUHALAudioUnit,
kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input,
AUHAL_INPUT_ELEMENT,
&auhalStreamFormat, &propSize);
if (err != kAudioHardwareNoError)
{
DEBUG_MSG ("Unable to get Input format, error = " << err);
retVal = eGenericErr;
goto Exit;
}
if (auhalStreamFormat.mSampleRate != (Float64)m_CurrentSamplingRate)
{
TRACE_MSG ("AUHAL's Input SR differs from expected SR, expected = " << m_CurrentSamplingRate << ", AUHAL's = " << (UInt32)auhalStreamFormat.mSampleRate);
}
//format, and slice size...
memset (&streamFormatToUse, 0, sizeof (streamFormatToUse));
streamFormatToUse.mFormatID = kAudioFormatLinearPCM;
streamFormatToUse.mFormatFlags = kAudioFormatFlagsNativeFloatPacked;
streamFormatToUse.mFramesPerPacket = 1;
streamFormatToUse.mBitsPerChannel = sizeof (float) * 8;
streamFormatToUse.mSampleRate = auhalStreamFormat.mSampleRate;
if (!m_InputChannels.empty())
{
streamFormatToUse.mChannelsPerFrame = m_InputChannels.size();
streamFormatToUse.mBytesPerFrame = sizeof (float)*streamFormatToUse.mChannelsPerFrame;
streamFormatToUse.mBytesPerPacket = streamFormatToUse.mBytesPerFrame;
propSize = sizeof (streamFormatToUse);
err = AudioUnitSetProperty(m_AUHALAudioUnit,
kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output,
AUHAL_INPUT_ELEMENT,
&streamFormatToUse, sizeof (streamFormatToUse));
if (err != kAudioHardwareNoError)
{
DEBUG_MSG ("Unable to set Input format, error = " << err);
retVal = eGenericErr;
goto Exit;
}
UInt32 bufferSize = m_CurrentBufferSize;
err = AudioUnitSetProperty(m_AUHALAudioUnit,
kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Output,
AUHAL_INPUT_ELEMENT,
&bufferSize, sizeof (bufferSize));
if (err != kAudioHardwareNoError)
{
DEBUG_MSG ("Unable to set Input frames, error = " << err);
retVal = eGenericErr;
goto Exit;
}
}
if (!m_OutputChannels.empty())
{
err = AudioUnitGetProperty(m_AUHALAudioUnit,
kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output,
AUHAL_OUTPUT_ELEMENT,
&auhalStreamFormat, &propSize);
if (err != kAudioHardwareNoError)
{
DEBUG_MSG ("Unable to get Output format, error = " << err);
retVal = eGenericErr;
goto Exit;
}
if (auhalStreamFormat.mSampleRate != (Float64)m_CurrentSamplingRate)
{
TRACE_MSG ("AUHAL's Output SR differs from expected SR, expected = " << m_CurrentSamplingRate << ", AUHAL's = " << (UInt32)auhalStreamFormat.mSampleRate);
}
streamFormatToUse.mChannelsPerFrame = m_OutputChannels.size();
streamFormatToUse.mBytesPerFrame = sizeof (float)*streamFormatToUse.mChannelsPerFrame;
streamFormatToUse.mBytesPerPacket = streamFormatToUse.mBytesPerFrame;
streamFormatToUse.mSampleRate = auhalStreamFormat.mSampleRate;
propSize = sizeof (streamFormatToUse);
err = AudioUnitSetProperty(m_AUHALAudioUnit,
kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input,
AUHAL_OUTPUT_ELEMENT,
&streamFormatToUse, sizeof (streamFormatToUse));
if (err != kAudioHardwareNoError)
{
DEBUG_MSG ("Unable to set Output format, error = " << err);
retVal = eGenericErr;
goto Exit;
}
UInt32 bufferSize = m_CurrentBufferSize;
err = AudioUnitSetProperty(m_AUHALAudioUnit,
kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Input,
AUHAL_OUTPUT_ELEMENT,
&bufferSize, sizeof (bufferSize));
if (err != kAudioHardwareNoError)
{
DEBUG_MSG ("Unable to set Output frames, error = " << err);
retVal = eGenericErr;
goto Exit;
}
}
//setup callback (IOProc)
{
AURenderCallbackStruct renderCallback;
memset (&renderCallback, 0, sizeof (renderCallback));
propSize = sizeof (renderCallback);
renderCallback.inputProc = StaticAudioIOProc;
renderCallback.inputProcRefCon = this;
err = AudioUnitSetProperty(m_AUHALAudioUnit,
(m_OutputChannels.empty() ? (AudioUnitPropertyID)kAudioOutputUnitProperty_SetInputCallback : (AudioUnitPropertyID)kAudioUnitProperty_SetRenderCallback),
kAudioUnitScope_Output,
m_OutputChannels.empty() ? AUHAL_INPUT_ELEMENT : AUHAL_OUTPUT_ELEMENT,
&renderCallback, sizeof (renderCallback));
if (err != kAudioHardwareNoError)
{
DEBUG_MSG ("Unable to set callback, error = " << err);
retVal = eGenericErr;
goto Exit;
}
}
retVal = EnableListeners();
if (retVal != eNoErr)
goto Exit;
//initialize the audio-unit now!
err = AudioUnitInitialize(m_AUHALAudioUnit);
if (err != kAudioHardwareNoError)
{
DEBUG_MSG ("Unable to Initialize AudioUnit = " << err);
retVal = eGenericErr;
goto Exit;
}
Exit:
if (retVal != eNoErr)
TearDownAUHAL();
return retVal;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::TearDownAUHAL
//
//! Undoes the work done by SetupAUHAL
//!
//! \param none
//!
//! \return eNoErr on success, an error code on failure.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::TearDownAUHAL()
{
WTErr retVal = eNoErr;
if (m_AUHALAudioUnit)
{
DisableListeners ();
AudioUnitUninitialize(m_AUHALAudioUnit);
CloseComponent(m_AUHALAudioUnit);
m_AUHALAudioUnit = NULL;
}
return retVal;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::SetActive
//
//! Sets the device's activation status. Essentially, opens or closes the PA device.
//! If it's an ASIO device it may result in buffer size change in some cases.
//!
//! \param newState : Should be true to activate, false to deactivate. This roughly corresponds
//! to opening and closing the device handle/stream/audio unit.
//!
//! \return eNoErr on success, an error code otherwise.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::SetActive (bool newState)
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
if (Active() == newState)
goto Exit;
if (newState)
{
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceDebugInfo, (void *)"Setting up AUHAL.");
retVal = SetupAUHAL();
if (retVal != eNoErr)
goto Exit;
m_BufferSizeChangeRequested = 0;
m_BufferSizeChangeReported = 0;
m_ResetRequested = 0;
m_ResetReported = 0;
m_ResyncRequested = 0;
m_ResyncReported = 0;
m_SRChangeRequested = 0;
m_SRChangeReported = 0;
m_DropsDetected = 0;
m_DropsReported = 0;
m_IgnoreThisDrop = true;
}
else
{
if (Streaming())
{
SetStreaming (false);
}
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceDebugInfo, (void *)"Tearing down AUHAL.");
retVal = TearDownAUHAL();
if (retVal != eNoErr)
goto Exit;
m_BufferSizeChangeRequested = 0;
m_BufferSizeChangeReported = 0;
m_ResetRequested = 0;
m_ResetReported = 0;
m_ResyncRequested = 0;
m_ResyncReported = 0;
m_SRChangeRequested = 0;
m_SRChangeReported = 0;
m_DropsDetected = 0;
m_DropsReported = 0;
m_IgnoreThisDrop = true;
UpdateDeviceInfo();
}
m_IsActive = newState;
Exit:
return (retVal);
}
#if WV_USE_TONE_GEN
//**********************************************************************************************
// WCMRCoreAudioDevice::SetupToneGenerator
//
//! Sets up the Tone generator - only if a file /tmp/tonegen.txt is present. If the file is
//! present, it reads the value in the file and uses that as the frequency for the tone. This
//! code attempts to create an array of samples that would constitute an integral number of
//! cycles - for the currently active sampling rate. If tonegen is active, then the input
//! from the audio device is ignored, instead a data is supplied from the tone generator's
//! array - for all channels. The array is in m_pToneData, the size of the array is in
//! m_ToneDataSamples, and m_NextSampleToUse holds the index in the array from where
//! the next sample is going to be taken.
//!
//!
//! \return : Nothing
//!
//**********************************************************************************************
void WCMRCoreAudioDevice::SetupToneGenerator ()
{
safe_delete_array(m_pToneData);
m_ToneDataSamples = 0;
//if tonegen exists?
FILE *toneGenHandle = fopen ("/tmp/tonegen.txt", "r");
if (toneGenHandle)
{
int toneFreq = 0;
fscanf(toneGenHandle, "%d", &toneFreq);
if ((toneFreq <= 0) || (toneFreq > (m_CurrentSamplingRate/2)))
{
toneFreq = 1000;
}
m_ToneDataSamples = m_CurrentSamplingRate / toneFreq;
int toneDataSamplesFrac = m_CurrentSamplingRate % m_ToneDataSamples;
int powerOfTen = 1;
while (toneDataSamplesFrac)
{
m_ToneDataSamples = (uint32_t)((pow(10, powerOfTen) * m_CurrentSamplingRate) / toneFreq);
toneDataSamplesFrac = m_CurrentSamplingRate % m_ToneDataSamples;
powerOfTen++;
}
//allocate
m_pToneData = new float_t[m_ToneDataSamples];
//fill with a -6dB Sine Tone
uint32_t numSamplesLeft = m_ToneDataSamples;
float_t *pNextSample = m_pToneData;
double phase = 0;
double phaseIncrement = (M_PI * 2.0 * toneFreq ) / ((double)m_CurrentSamplingRate);
while (numSamplesLeft)
{
*pNextSample = (float_t)(0.5 * sin(phase));
phase += phaseIncrement;
pNextSample++;
numSamplesLeft--;
}
m_NextSampleToUse = 0;
fclose(toneGenHandle);
}
}
#endif //WV_USE_TONE_GEN
//**********************************************************************************************
// WCMRCoreAudioDevice::SetStreaming
//
//! Sets the device's streaming status. Calls PA's Start/Stop stream routines.
//!
//! \param newState : Should be true to start streaming, false to stop streaming. This roughly
//! corresponds to calling Start/Stop on the lower level interface.
//!
//! \return eNoErr always, the derived classes may return appropriate error code.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::SetStreaming (bool newState)
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
ComponentResult err = 0;
if (Streaming () == newState)
goto Exit;
if (newState)
{
#if WV_USE_TONE_GEN
SetupToneGenerator ();
#endif //WV_USE_TONE_GEN
m_SampleCountAtLastIdle = 0;
m_StalledSampleCounter = 0;
m_SampleCounter = 0;
m_IOProcThreadPort = 0;
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceDebugInfo, (void *)"Starting AUHAL.");
// Prepare for streaming - tell Engine to do the initialization for process callback
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceStartsStreaming);
if (m_UseMultithreading)
{
//set thread constraints...
unsigned int periodAndConstraintUS = (unsigned int)((1000000.0 * m_CurrentBufferSize) / m_CurrentSamplingRate);
unsigned int computationUS = (unsigned int)(0.8 * periodAndConstraintUS); //assuming we may want to use up to 80% CPU
//ErrandManager().SetRealTimeConstraintsForAllThreads (periodAndConstraintUS, computationUS, periodAndConstraintUS);
}
err = AudioOutputUnitStart (m_AUHALAudioUnit);
m_StopRequested = false;
if(err)
{
DEBUG_MSG( "Failed to start AudioUnit, err " << err );
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceDebugInfo, (void *)"Failed to start AudioUnit.");
retVal = eGenericErr;
goto Exit;
}
}
else
{
m_StopRequested = true;
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceDebugInfo, (void *)"Stopping AUHAL.");
err = AudioOutputUnitStop (m_AUHALAudioUnit);
if (!err)
{
//if (!m_InputChannels.empty());
{
err = AudioUnitReset (m_AUHALAudioUnit, kAudioUnitScope_Global, AUHAL_INPUT_ELEMENT);
}
//if (!m_OutputChannels.empty());
{
err = AudioUnitReset (m_AUHALAudioUnit, kAudioUnitScope_Global, AUHAL_OUTPUT_ELEMENT);
}
}
if(err)
{
DEBUG_MSG( "Failed to stop AudioUnit " << err );
retVal = eGenericErr;
goto Exit;
}
m_IOProcThreadPort = 0;
}
// After units restart, reset request for reset and SR change
m_SRChangeReported = m_SRChangeRequested;
m_ResetReported = m_ResetRequested;
m_IsStreaming = newState;
Exit:
return (retVal);
}
//**********************************************************************************************
// WCMRCoreAudioDevice::DoIdle
//
//! A place for doing idle time processing. The other derived classes will probably do something
//! meaningful.
//!
//! \param none
//!
//! \return eNoErr always.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::DoIdle ()
{
/*
if (m_BufferSizeChangeRequested != m_BufferSizeChangeReported)
{
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::BufferSizeChanged);
m_BufferSizeChangeReported = m_BufferSizeChangeRequested;
}
if (m_ResetRequested != m_ResetReported)
{
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::RequestReset);
m_ResetReported = m_ResetRequested;
}
if (m_ResyncRequested != m_ResyncReported)
{
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::RequestResync);
m_ResyncReported = m_ResyncRequested;
}
if (m_SRChangeReported != m_SRChangeRequested)
{
m_SRChangeReported = m_SRChangeRequested;
int newSR = CurrentSamplingRate();
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::SamplingRateChanged, (void *)newSR);
}
if (m_DropsReported != m_DropsDetected)
{
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceDroppedSamples);
m_DropsReported = m_DropsDetected;
}
//Perhaps add checks to make sure a stream counter is incrementing if
//stream is supposed to be streaming!
if (Streaming())
{
//latch the value
int64_t currentSampleCount = m_SampleCounter;
if (m_SampleCountAtLastIdle == currentSampleCount)
m_StalledSampleCounter++;
else
{
m_SampleCountAtLastIdle = (int)currentSampleCount;
m_StalledSampleCounter = 0;
}
if (m_StalledSampleCounter > NUM_STALLS_FOR_NOTIFICATION)
{
m_StalledSampleCounter = 0;
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::DeviceStoppedStreaming, (void *)currentSampleCount);
}
}*/
return (eNoErr);
}
//**********************************************************************************************
// WCMRCoreAudioDevice::SetMonitorChannels
//
//! Used to set the channels to be used for monitoring.
//!
//! \param leftChannel : Left monitor channel index.
//! \param rightChannel : Right monitor channel index.
//!
//! \return eNoErr always, the derived classes may return appropriate errors.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::SetMonitorChannels (int leftChannel, int rightChannel)
{
AUTO_FUNC_DEBUG;
//This will most likely be overridden, the base class simply
//changes the member.
m_LeftMonitorChannel = leftChannel;
m_RightMonitorChannel = rightChannel;
return (eNoErr);
}
//**********************************************************************************************
// WCMRCoreAudioDevice::SetMonitorGain
//
//! Used to set monitor gain (or atten).
//!
//! \param newGain : The new gain or atten. value to use. Specified as a linear multiplier (not dB)
//!
//! \return eNoErr always, the derived classes may return appropriate errors.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::SetMonitorGain (float newGain)
{
AUTO_FUNC_DEBUG;
//This will most likely be overridden, the base class simply
//changes the member.
m_MonitorGain = newGain;
return (eNoErr);
}
//**********************************************************************************************
// WCMRCoreAudioDevice::ShowConfigPanel
//
//! Used to show device specific config/control panel. Some interfaces may not support it.
//! Some interfaces may require the device to be active before it can display a panel.
//!
//! \param pParam : A device/interface specific parameter, should be the app window handle for ASIO.
//!
//! \return eNoErr always, the derived classes may return errors.
//!
//**********************************************************************************************
WTErr WCMRCoreAudioDevice::ShowConfigPanel (void */*pParam*/)
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
CFStringRef configAP;
UInt32 propSize = sizeof (configAP);
/*
@constant kAudioDevicePropertyConfigurationApplication
A CFString that contains the bundle ID for an application that provides a
GUI for configuring the AudioDevice. By default, the value of this property
is the bundle ID for Audio MIDI Setup. The caller is responsible for
releasing the returned CFObject.
*/
if (AudioDeviceGetProperty(m_DeviceID, 0, 0, kAudioDevicePropertyConfigurationApplication, &propSize, &configAP) == kAudioHardwareNoError)
{
// get the FSRef of the config app
FSRef theAppFSRef;
OSStatus theError = LSFindApplicationForInfo(kLSUnknownCreator, configAP, NULL, &theAppFSRef, NULL);
if (!theError)
{
LSOpenFSRef(&theAppFSRef, NULL);
}
else
{
// open default AudioMIDISetup if device app is not found
CFStringRef audiMidiSetupApp = CFStringCreateWithCString(kCFAllocatorDefault, "com.apple.audio.AudioMIDISetup", kCFStringEncodingMacRoman);
theError = LSFindApplicationForInfo(kLSUnknownCreator, audiMidiSetupApp, NULL, &theAppFSRef, NULL);
if (!theError)
{
LSOpenFSRef(&theAppFSRef, NULL);
}
}
CFRelease (configAP);
}
return (retVal);
}
//**********************************************************************************************
// WCMRCoreAudioDevice::StaticAudioIOProc
//
//! The AudioIOProc that gets called when the AudioUnit is ready with recorded audio, and wants to get audio.
//! This one simply calls the non-static member.
//!
//! \param inRefCon : What was passed when setting up the Callback (in our case a pointer to teh WCMRCoreAudioDevice object).
//! \param ioActionFlags : What actios has to be taken.
//! \param inTimeStamp: When the data will be played back.
//! \param inBusNumber : The AU element.
//! \param inNumberFrames: Number af Audio frames that are requested.
//! \param ioData : Where the playback data is to be placed.
//!
//! \return 0 always
//!
//**********************************************************************************************
OSStatus WCMRCoreAudioDevice::StaticAudioIOProc(void *inRefCon, AudioUnitRenderActionFlags * ioActionFlags,
const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames,
AudioBufferList *ioData)
{
WCMRCoreAudioDevice *pMyDevice = (WCMRCoreAudioDevice *)inRefCon;
if (pMyDevice)
return pMyDevice->AudioIOProc (ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, ioData);
else
return 0;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::AudioIOProc
//
//! The non-static AudioIOProc that gets called when the AudioUnit is ready with recorded audio, and wants to get audio.
//! We retrieve the recorded audio, and then do our processing, to generate audio to be played back.
//!
//! \param ioActionFlags : What actios has to be taken.
//! \param inTimeStamp: When the data will be played back.
//! \param inBusNumber : The AU element.
//! \param inNumberFrames: Number af Audio frames that are requested.
//! \param ioData : Where the playback data is to be placed.
//!
//! \return 0 always
//!
//**********************************************************************************************
OSStatus WCMRCoreAudioDevice::AudioIOProc(AudioUnitRenderActionFlags * ioActionFlags,
const AudioTimeStamp *inTimeStamp, UInt32 /*inBusNumber*/, UInt32 inNumberFrames,
AudioBufferList *ioData)
{
UInt64 theStartTime = AudioGetCurrentHostTime();
OSStatus retVal = 0;
if (m_StopRequested)
return retVal;
if (m_IOProcThreadPort == 0)
m_IOProcThreadPort = mach_thread_self ();
//cannot really deal with it unless the number of frames are the same as our buffer size!
if (inNumberFrames != (UInt32)m_CurrentBufferSize)
return retVal;
//Retrieve the input data...
if (!m_InputChannels.empty())
{
UInt32 expectedDataSize = m_InputChannels.size() * m_CurrentBufferSize * sizeof(float);
AudioBufferList inputAudioBufferList;
inputAudioBufferList.mNumberBuffers = 1;
inputAudioBufferList.mBuffers[0].mNumberChannels = m_InputChannels.size();
inputAudioBufferList.mBuffers[0].mDataByteSize = expectedDataSize;
inputAudioBufferList.mBuffers[0].mData = NULL;//new float[expectedDataSize]; // we are going to get buffer from CoreAudio
retVal = AudioUnitRender(m_AUHALAudioUnit, ioActionFlags, inTimeStamp, AUHAL_INPUT_ELEMENT, inNumberFrames, &inputAudioBufferList);
if (retVal == kAudioHardwareNoError &&
inputAudioBufferList.mBuffers[0].mNumberChannels == m_InputChannels.size() &&
inputAudioBufferList.mBuffers[0].mDataByteSize == expectedDataSize )
{
m_pInputData = (float*)inputAudioBufferList.mBuffers[0].mData;
}
else
{
m_pInputData = NULL;
return retVal;
}
}
//is this an input only device?
if (m_OutputChannels.empty())
AudioCallback (NULL, inNumberFrames, (int64_t)inTimeStamp->mSampleTime, theStartTime);
else if ((!m_OutputChannels.empty()) && (ioData->mBuffers[0].mNumberChannels == m_OutputChannels.size()))
AudioCallback ((float *)ioData->mBuffers[0].mData, inNumberFrames, (int64_t)inTimeStamp->mSampleTime, theStartTime);
return retVal;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::AudioCallback
//
//! Here's where the actual audio processing happens. We call upon all the active connections'
//! sinks to provide data to us which can be put/mixed in the output buffer! Also, we make the
//! input data available to any sources that may call upon us during this time!
//!
//! \param *pOutputBuffer : Points to a buffer to receive playback data. For Input only devices, this will be NULL
//! \param framesPerBuffer : Number of sample frames in input and output buffers. Number of channels,
//! which are interleaved, is fixed at Device Open (Active) time. In this implementation,
//! the number of channels are fixed to use the maximum available.
//!
//! \return true
//!
//**********************************************************************************************
int WCMRCoreAudioDevice::AudioCallback (float *pOutputBuffer, unsigned long framesPerBuffer, int64_t inSampleTime, uint64_t inCycleStartTime)
{
struct WCMRAudioDeviceManagerClient::AudioCallbackData audioCallbackData =
{
m_pInputData,
pOutputBuffer,
framesPerBuffer,
inSampleTime,
AudioConvertHostTimeToNanos(inCycleStartTime)
};
m_pMyManager->NotifyClient (WCMRAudioDeviceManagerClient::AudioCallback, (void *)&audioCallbackData);
m_SampleCounter += framesPerBuffer;
return m_StopRequested;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::GetLatency
//
//! Get Latency for device.
//!
//! Use 'kAudioDevicePropertyLatency' and 'kAudioDevicePropertySafetyOffset' + GetStreamLatencies
//!
//! \param isInput : Return latency for the input if isInput is true, otherwise the output latency
//! wiil be returned.
//! \return Latency in samples.
//!
//**********************************************************************************************
uint32_t WCMRCoreAudioDevice::GetLatency(bool isInput)
{
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 propSize = sizeof(UInt32);
UInt32 value1 = 0;
UInt32 value2 = 0;
UInt32 latency = 0;
std::vector<int> streamLatencies;
err = AudioDeviceGetProperty(m_DeviceID, 0, isInput, kAudioDevicePropertyLatency, &propSize, &value1);
if (err != kAudioHardwareNoError)
{
DEBUG_MSG("GetLatency kAudioDevicePropertyLatency err = " << err);
}
err = AudioDeviceGetProperty(m_DeviceID, 0, isInput, kAudioDevicePropertySafetyOffset, &propSize, &value2);
if (err != kAudioHardwareNoError)
{
DEBUG_MSG("GetLatency kAudioDevicePropertySafetyOffset err = " << err);
}
latency = value1 + value2;
err = GetStreamLatency(m_DeviceID, isInput, streamLatencies);
if (err == kAudioHardwareNoError)
{
for ( int i = 0; i < streamLatencies.size(); i++) {
latency += streamLatencies[i];
}
}
return latency;
}
//**********************************************************************************************
// WCMRCoreAudioDevice::GetStreamLatency
//
//! Get stream latency for device.
//!
//! \param deviceID : The audio device ID.
//!
//! \param isInput : Return latency for the input if isInput is true, otherwise the output latency
//! wiil be returned.
//**********************************************************************************************
OSStatus WCMRCoreAudioDevice::GetStreamLatency(AudioDeviceID device, bool isInput, std::vector<int>& latencies)
{
OSStatus err = kAudioHardwareNoError;
UInt32 outSize1, outSize2, outSize3;
Boolean outWritable;
err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreams, &outSize1, &outWritable);
if (err == noErr) {
int stream_count = outSize1 / sizeof(UInt32);
AudioStreamID streamIDs[stream_count];
AudioBufferList bufferList[stream_count];
UInt32 streamLatency;
outSize2 = sizeof(UInt32);
err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreams, &outSize1, streamIDs);
if (err != noErr) {
DEBUG_MSG("GetStreamLatencies kAudioDevicePropertyStreams err = " << err);
return err;
}
err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize3, &outWritable);
if (err != noErr) {
DEBUG_MSG("GetStreamLatencies kAudioDevicePropertyStreamConfiguration err = " << err);
return err;
}
for (int i = 0; i < stream_count; i++) {
err = AudioStreamGetProperty(streamIDs[i], 0, kAudioStreamPropertyLatency, &outSize2, &streamLatency);
if (err != noErr) {
DEBUG_MSG("GetStreamLatencies kAudioStreamPropertyLatency err = " << err);
return err;
}
err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize3, bufferList);
if (err != noErr) {
DEBUG_MSG("GetStreamLatencies kAudioDevicePropertyStreamConfiguration err = " << err);
return err;
}
latencies.push_back(streamLatency);
}
}
return err;
}
//**********************************************************************************************
// WCMRCoreAudioDeviceManager::WCMRCoreAudioDeviceManager
//
//! The constructuor, we initialize PA, and build the device list.
//!
//! \param *pTheClient : The manager's client object (which receives notifications).
//! \param useMultithreading : Whether to use multi-threading for audio processing. Default is true.
//!
//! \return Nothing.
//!
//**********************************************************************************************
WCMRCoreAudioDeviceManager::WCMRCoreAudioDeviceManager(WCMRAudioDeviceManagerClient *pTheClient,
eAudioDeviceFilter eCurAudioDeviceFilter, bool useMultithreading, bool bNocopy)
: WCMRAudioDeviceManager (pTheClient, eCurAudioDeviceFilter)
, m_UseMultithreading (useMultithreading)
, m_bNoCopyAudioBuffer(bNocopy)
{
AUTO_FUNC_DEBUG;
//first of all, tell HAL to use it's own run loop, not to wait for our runloop to do
//it's dirty work...
//Essentially, this makes the HAL on Snow Leopard behave like Leopard.
//It's not yet (as of October 2009 documented), but the following discussion
//has the information provided by Jeff Moore @ Apple:
// http://lists.apple.com/archives/coreaudio-api/2009/Oct/msg00214.html
//
// As per Jeff's suggestion, opened an Apple Bug on this - ID# 7364011
CFRunLoopRef nullRunLoop = 0;
OSStatus err = AudioHardwareSetProperty (kAudioHardwarePropertyRunLoop, sizeof(CFRunLoopRef), &nullRunLoop);
if (err != kAudioHardwareNoError)
{
syslog (LOG_NOTICE, "Unable to set RunLoop for Audio Hardware");
}
//add a listener to find out when devices change...
AudioHardwareAddPropertyListener (kAudioHardwarePropertyDevices, HardwarePropertyChangeCallback, this);
//Always add the None device first...
m_NoneDevice = new WCMRNativeAudioNoneDevice(this);
//prepare our initial list...
generateDeviceListImpl();
return;
}
//**********************************************************************************************
// WCMRCoreAudioDeviceManager::~WCMRCoreAudioDeviceManager
//
//! It clears the device list, releasing each of the device.
//!
//! \param none
//!
//! \return Nothing.
//!
//**********************************************************************************************
WCMRCoreAudioDeviceManager::~WCMRCoreAudioDeviceManager()
{
AUTO_FUNC_DEBUG;
try
{
delete m_NoneDevice;
}
catch (...)
{
//destructors should absorb exceptions, no harm in logging though!!
DEBUG_MSG ("Exception during destructor");
}
}
WCMRAudioDevice* WCMRCoreAudioDeviceManager::initNewCurrentDeviceImpl(const std::string & deviceName)
{
destroyCurrentDeviceImpl();
std::cout << "API::PortAudioDeviceManager::initNewCurrentDevice " << deviceName << std::endl;
if (deviceName == m_NoneDevice->DeviceName() )
{
m_CurrentDevice = m_NoneDevice;
return m_CurrentDevice;
}
DeviceInfo devInfo;
WTErr err = GetDeviceInfoByName(deviceName, devInfo);
if (eNoErr == err)
{
try
{
std::cout << "API::PortAudioDeviceManager::Creating PA device: " << devInfo.m_DeviceId << ", Device Name: " << devInfo.m_DeviceName << std::endl;
TRACE_MSG ("API::PortAudioDeviceManager::Creating PA device: " << devInfo.m_DeviceId << ", Device Name: " << devInfo.m_DeviceName);
m_CurrentDevice = new WCMRCoreAudioDevice (this, devInfo.m_DeviceId, m_UseMultithreading, m_bNoCopyAudioBuffer);
}
catch (...)
{
std::cout << "Unabled to create PA Device: " << devInfo.m_DeviceId << std::endl;
DEBUG_MSG ("Unabled to create PA Device: " << devInfo.m_DeviceId);
}
}
return m_CurrentDevice;
}
void WCMRCoreAudioDeviceManager::destroyCurrentDeviceImpl()
{
if (m_CurrentDevice != m_NoneDevice)
delete m_CurrentDevice;
m_CurrentDevice = 0;
}
WTErr WCMRCoreAudioDeviceManager::getDeviceAvailableSampleRates(DeviceID deviceId, std::vector<int>& sampleRates)
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 propSize = 0;
sampleRates.clear();
//! 1. Get sample rate property size.
err = AudioDeviceGetPropertyInfo(deviceId, 0, 0, kAudioDevicePropertyAvailableNominalSampleRates, &propSize, NULL);
if (err == kAudioHardwareNoError)
{
//! 2. Get property: cannels output.
// Allocate size according to the number of audio values
int numRates = propSize / sizeof(AudioValueRange);
AudioValueRange* supportedRates = new AudioValueRange[numRates];
// Get sampling rates from Audio device
err = AudioDeviceGetProperty(deviceId, 0, 0, kAudioDevicePropertyAvailableNominalSampleRates, &propSize, supportedRates);
if (err == kAudioHardwareNoError)
{
//! 3. Update sample rates
// now iterate through our standard SRs
for(int ourSR=0; gAllSampleRates[ourSR] > 0; ourSR++)
{
//check to see if our SR is in the supported rates...
for (int deviceSR = 0; deviceSR < numRates; deviceSR++)
{
if ((supportedRates[deviceSR].mMinimum <= gAllSampleRates[ourSR]) &&
(supportedRates[deviceSR].mMaximum >= gAllSampleRates[ourSR]))
{
sampleRates.push_back ((int)gAllSampleRates[ourSR]);
break;
}
}
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Sample rates. Device Name: " << m_DeviceName.c_str());
}
delete [] supportedRates;
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Sample rates property size. Device Name: " << m_DeviceName.c_str());
}
return retVal;
}
WTErr WCMRCoreAudioDeviceManager::getDeviceMaxInputChannels(DeviceID deviceId, unsigned int& inputChannels)
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 propSize = 0;
inputChannels = 0;
// 1. Get property cannels input size.
err = AudioDeviceGetPropertyInfo (deviceId, 0, 1/* Input */, kAudioDevicePropertyStreamConfiguration, &propSize, NULL);
if (err == kAudioHardwareNoError)
{
//! 2. Get property: cannels input.
// Allocate size according to the property size. Note that this is a variable sized struct...
AudioBufferList *pStreamBuffers = (AudioBufferList *)malloc(propSize);
if (pStreamBuffers)
{
memset (pStreamBuffers, 0, propSize);
// Get the Input channels
err = AudioDeviceGetProperty (deviceId, 0, 1/* Input */, kAudioDevicePropertyStreamConfiguration, &propSize, pStreamBuffers);
if (err == kAudioHardwareNoError)
{
// Calculate the number of input channels
for (UInt32 streamIndex = 0; streamIndex < pStreamBuffers->mNumberBuffers; streamIndex++)
{
inputChannels += pStreamBuffers->mBuffers[streamIndex].mNumberChannels;
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Input channels. Device Name: " << m_DeviceName.c_str());
}
free (pStreamBuffers);
}
else
{
retVal = eMemOutOfMemory;
DEBUG_MSG("Faild to allocate memory. Device Name: " << m_DeviceName.c_str());
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Input channels property size. Device Name: " << m_DeviceName.c_str());
}
return retVal;
}
WTErr WCMRCoreAudioDeviceManager::getDeviceMaxOutputChannels(DeviceID deviceId, unsigned int& outputChannels)
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 propSize = 0;
outputChannels = 0;
//! 1. Get property cannels output size.
err = AudioDeviceGetPropertyInfo (deviceId, 0, 0/* Output */, kAudioDevicePropertyStreamConfiguration, &propSize, NULL);
if (err == kAudioHardwareNoError)
{
//! 2. Get property: cannels output.
// Allocate size according to the property size. Note that this is a variable sized struct...
AudioBufferList *pStreamBuffers = (AudioBufferList *)malloc(propSize);
if (pStreamBuffers)
{
memset (pStreamBuffers, 0, propSize);
// Get the Output channels
err = AudioDeviceGetProperty (deviceId, 0, 0/* Output */, kAudioDevicePropertyStreamConfiguration, &propSize, pStreamBuffers);
if (err == kAudioHardwareNoError)
{
// Calculate the number of output channels
for (UInt32 streamIndex = 0; streamIndex < pStreamBuffers->mNumberBuffers; streamIndex++)
{
outputChannels += pStreamBuffers->mBuffers[streamIndex].mNumberChannels;
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Output channels. Device Name: " << m_DeviceName.c_str());
}
free (pStreamBuffers);
}
else
{
retVal = eMemOutOfMemory;
DEBUG_MSG("Faild to allocate memory. Device Name: " << m_DeviceName.c_str());
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Output channels property size. Device Name: " << m_DeviceName.c_str());
}
return retVal;
}
WTErr WCMRCoreAudioDeviceManager::generateDeviceListImpl()
{
AUTO_FUNC_DEBUG;
// lock the list first
wvNS::wvThread::ThreadMutex::lock theLock(m_AudioDeviceInfoVecMutex);
m_DeviceInfoVec.clear();
//First, get info from None device which is always present
if (m_NoneDevice)
{
DeviceInfo *pDevInfo = new DeviceInfo(NONE_DEVICE_ID, m_NoneDevice->DeviceName() );
pDevInfo->m_AvailableSampleRates = m_NoneDevice->SamplingRates();
m_DeviceInfoVec.push_back(pDevInfo);
}
WTErr retVal = eNoErr;
OSStatus osErr = noErr;
AudioDeviceID* deviceIDs = 0;
openlog("WCMRCoreAudioDeviceManager", LOG_PID | LOG_CONS, LOG_USER);
try
{
//Get device count...
UInt32 propSize = 0;
osErr = AudioHardwareGetPropertyInfo (kAudioHardwarePropertyDevices, &propSize, NULL);
ASSERT_ERROR(osErr, "AudioHardwareGetProperty 1");
if (WUIsError(osErr))
throw osErr;
size_t numDevices = propSize / sizeof (AudioDeviceID);
deviceIDs = new AudioDeviceID[numDevices];
//retrieve the device IDs
propSize = numDevices * sizeof (AudioDeviceID);
osErr = AudioHardwareGetProperty (kAudioHardwarePropertyDevices, &propSize, deviceIDs);
ASSERT_ERROR(osErr, "Error while getting audio devices: AudioHardwareGetProperty 2");
if (WUIsError(osErr))
throw osErr;
//now add the ones that are not there...
for (size_t deviceIndex = 0; deviceIndex < numDevices; deviceIndex++)
{
DeviceInfo* pDevInfo = 0;
//Get device name and create new DeviceInfo entry
//Get property name size.
osErr = AudioDeviceGetPropertyInfo(deviceIDs[deviceIndex], 0, 0, kAudioDevicePropertyDeviceName, &propSize, NULL);
if (osErr == kAudioHardwareNoError)
{
//Get property: name.
char* deviceName = new char[propSize];
osErr = AudioDeviceGetProperty(deviceIDs[deviceIndex], 0, 0, kAudioDevicePropertyDeviceName, &propSize, deviceName);
if (osErr == kAudioHardwareNoError)
{
pDevInfo = new DeviceInfo(deviceIDs[deviceIndex], deviceName);
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device name. Device ID: " << m_DeviceID);
}
delete [] deviceName;
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device name property size. Device ID: " << m_DeviceID);
}
if (pDevInfo)
{
//Retrieve all the information we need for the device
WTErr wErr = eNoErr;
//Get available sample rates for the device
std::vector<int> availableSampleRates;
wErr = getDeviceAvailableSampleRates(pDevInfo->m_DeviceId, availableSampleRates);
if (wErr != eNoErr)
{
DEBUG_MSG ("Failed to get device available sample rates. Device ID: " << m_DeviceID);
delete pDevInfo;
continue; //proceed to the next device
}
pDevInfo->m_AvailableSampleRates = availableSampleRates;
//Get max input channels
uint32_t maxInputChannels;
wErr = getDeviceMaxInputChannels(pDevInfo->m_DeviceId, maxInputChannels);
if (wErr != eNoErr)
{
DEBUG_MSG ("Failed to get device max input channels count. Device ID: " << m_DeviceID);
delete pDevInfo;
continue; //proceed to the next device
}
pDevInfo->m_MaxInputChannels = maxInputChannels;
//Get max output channels
uint32_t maxOutputChannels;
wErr = getDeviceMaxOutputChannels(pDevInfo->m_DeviceId, maxOutputChannels);
if (wErr != eNoErr)
{
DEBUG_MSG ("Failed to get device max output channels count. Device ID: " << m_DeviceID);
delete pDevInfo;
continue; //proceed to the next device
}
pDevInfo->m_MaxOutputChannels = maxOutputChannels;
//Now check if this device is acceptable according to current input/output settings
bool bRejectDevice = false;
switch(m_eAudioDeviceFilter)
{
case eInputOnlyDevices:
if (pDevInfo->m_MaxInputChannels != 0)
{
m_DeviceInfoVec.push_back(pDevInfo);
}
else
{
// Delete unnecesarry device
bRejectDevice = true;
}
break;
case eOutputOnlyDevices:
if (pDevInfo->m_MaxOutputChannels != 0)
{
m_DeviceInfoVec.push_back(pDevInfo);
}
else
{
// Delete unnecesarry device
bRejectDevice = true;
}
break;
case eFullDuplexDevices:
if (pDevInfo->m_MaxInputChannels != 0 && pDevInfo->m_MaxOutputChannels != 0)
{
m_DeviceInfoVec.push_back(pDevInfo);
}
else
{
// Delete unnecesarry device
bRejectDevice = true;
}
break;
case eAllDevices:
default:
m_DeviceInfoVec.push_back(pDevInfo);
break;
}
if(bRejectDevice)
{
syslog (LOG_NOTICE, "%s rejected, In Channels = %d, Out Channels = %d\n",
pDevInfo->m_DeviceName.c_str(), pDevInfo->m_MaxInputChannels, pDevInfo->m_MaxOutputChannels);
// In case of Input and Output both channels being Zero, we will release memory; since we created CoreAudioDevice but we are Not adding it in list.
delete pDevInfo;
}
}
}
//If no devices were found, that's not a good thing!
if (m_DeviceInfoVec.empty())
{
DEBUG_MSG ("No matching CoreAudio devices were found\n");
}
}
catch (...)
{
if (WUNoError(retVal))
retVal = eCoreAudioFailed;
}
delete[] deviceIDs;
closelog();
return retVal;
}
WTErr WCMRCoreAudioDeviceManager::updateDeviceListImpl()
{
wvNS::wvThread::ThreadMutex::lock theLock(m_AudioDeviceInfoVecMutex);
WTErr err = generateDeviceListImpl();
if (eNoErr != err)
{
std::cout << "API::PortAudioDeviceManager::updateDeviceListImpl: Device list update error: "<< err << std::endl;
}
if (m_CurrentDevice)
{
// if we have device initialized we should find out if this device is still connected
DeviceInfo devInfo;
WTErr deviceLookUpErr = GetDeviceInfoByName(m_CurrentDevice->DeviceName(), devInfo );
if (eNoErr != deviceLookUpErr)
{
NotifyClient (WCMRAudioDeviceManagerClient::IODeviceDisconnected);
return err;
}
WCMRCoreAudioDevice* current_device = dynamic_cast<WCMRCoreAudioDevice*>(m_CurrentDevice);
if ( current_device &&
(current_device->DeviceID() != devInfo.m_DeviceId ) )
{
NotifyClient (WCMRAudioDeviceManagerClient::RequestReset);
return err;
}
}
NotifyClient (WCMRAudioDeviceManagerClient::DeviceListChanged);
return err;
}
WTErr WCMRCoreAudioDeviceManager::getDeviceSampleRatesImpl(const std::string & deviceName, std::vector<int>& sampleRates) const
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 propSize = 0;
sampleRates.clear();
//first check if the request has been made for None device
if (deviceName == m_NoneDevice->DeviceName() )
{
sampleRates = m_NoneDevice->SamplingRates();
return retVal;
}
if (m_CurrentDevice && m_CurrentDevice->DeviceName () == deviceName) {
sampleRates.assign(m_CurrentDevice->SamplingRates().begin(), m_CurrentDevice->SamplingRates().end() );
return retVal;
}
DeviceInfo devInfo;
retVal = GetDeviceInfoByName(deviceName, devInfo);
//! 1. Get sample rate property size.
err = AudioDeviceGetPropertyInfo(devInfo.m_DeviceId, 0, 0, kAudioDevicePropertyAvailableNominalSampleRates, &propSize, NULL);
if (err == kAudioHardwareNoError)
{
//! 2. Get property: cannels output.
// Allocate size accrding to the number of audio values
int numRates = propSize / sizeof(AudioValueRange);
AudioValueRange* supportedRates = new AudioValueRange[numRates];
// Get sampling rates from Audio device
err = AudioDeviceGetProperty(devInfo.m_DeviceId, 0, 0, kAudioDevicePropertyAvailableNominalSampleRates, &propSize, supportedRates);
if (err == kAudioHardwareNoError)
{
//! 3. Update sample rates
// now iterate through our standard SRs
for(int ourSR=0; gAllSampleRates[ourSR] > 0; ourSR++)
{
//check to see if our SR is in the supported rates...
for (int deviceSR = 0; deviceSR < numRates; deviceSR++)
{
if ((supportedRates[deviceSR].mMinimum <= gAllSampleRates[ourSR]) &&
(supportedRates[deviceSR].mMaximum >= gAllSampleRates[ourSR]))
{
sampleRates.push_back ((int)gAllSampleRates[ourSR]);
break;
}
}
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Sample rates. Device Name: " << m_DeviceName.c_str());
}
delete [] supportedRates;
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device Sample rates property size. Device Name: " << m_DeviceName.c_str());
}
devInfo.m_AvailableSampleRates.assign(sampleRates.begin(), sampleRates.end() );
return retVal;
}
WTErr WCMRCoreAudioDeviceManager::getDeviceBufferSizesImpl(const std::string & deviceName, std::vector<int>& bufferSizes) const
{
AUTO_FUNC_DEBUG;
WTErr retVal = eNoErr;
OSStatus err = kAudioHardwareNoError;
UInt32 propSize = 0;
bufferSizes.clear();
//first check if the request has been made for None device
if (deviceName == m_NoneDevice->DeviceName() )
{
bufferSizes = m_NoneDevice->BufferSizes();
return retVal;
}
if (m_CurrentDevice && m_CurrentDevice->DeviceName () == deviceName) {
bufferSizes.assign(m_CurrentDevice->BufferSizes().begin(), m_CurrentDevice->BufferSizes().end() );
return retVal;
}
DeviceInfo devInfo;
retVal = GetDeviceInfoByName(deviceName, devInfo);
if (eNoErr == retVal)
{
// 1. Get buffer size range
AudioValueRange bufferSizesRange;
propSize = sizeof (AudioValueRange);
err = AudioDeviceGetProperty (devInfo.m_DeviceId, 0, 0, kAudioDevicePropertyBufferFrameSizeRange, &propSize, &bufferSizesRange);
if(err == kAudioHardwareNoError)
{
// 2. Run on all ranges and add them to the list
for(int bsize=0; gAllBufferSizes[bsize] > 0; bsize++)
{
if ((bufferSizesRange.mMinimum <= gAllBufferSizes[bsize]) && (bufferSizesRange.mMaximum >= gAllBufferSizes[bsize]))
{
bufferSizes.push_back (gAllBufferSizes[bsize]);
}
}
//if we didn't get a single hit, let's simply add the min. and the max...
if (bufferSizes.empty())
{
bufferSizes.push_back ((int)bufferSizesRange.mMinimum);
bufferSizes.push_back ((int)bufferSizesRange.mMaximum);
}
}
else
{
retVal = eCoreAudioFailed;
DEBUG_MSG("Failed to get device buffer sizes range. Device Name: " << m_DeviceName.c_str());
}
}
else
{
retVal = eRMResNotFound;
std::cout << "API::PortAudioDeviceManager::GetBufferSizes: Device not found: "<< deviceName << std::endl;
}
return retVal;
}
OSStatus WCMRCoreAudioDeviceManager::HardwarePropertyChangeCallback (AudioHardwarePropertyID inPropertyID, void* inClientData)
{
switch (inPropertyID)
{
case kAudioHardwarePropertyDevices:
{
WCMRCoreAudioDeviceManager* pManager = (WCMRCoreAudioDeviceManager*)inClientData;
if (pManager)
pManager->updateDeviceListImpl();
}
break;
default:
break;
}
return 0;
}
View Git Blame Copy Permalink