3141 lines
107 KiB
C++
3141 lines
107 KiB
C++
//----------------------------------------------------------------------------------
|
|
//
|
|
// 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, ¤tNominalRate) != kAudioHardwareNoError)
|
|
err = AudioDeviceGetProperty(m_DeviceID, 0, 1, kAudioDevicePropertyNominalSampleRate, &propSize, ¤tNominalRate);
|
|
|
|
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, ¤tNominalRate) != kAudioHardwareNoError)
|
|
err = AudioDeviceGetProperty(m_DeviceID, 0, 1, kAudioDevicePropertyNominalSampleRate, &propSize, ¤tNominalRate);
|
|
|
|
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;
|
|
}
|