594 lines
16 KiB
C++
594 lines
16 KiB
C++
#include "ehs/io/audio/AudioDevice_W32.h"
|
|
#include "ehs/Log.h"
|
|
|
|
namespace ehs
|
|
{
|
|
AudioDevice::~AudioDevice()
|
|
{
|
|
if (hdl)
|
|
{
|
|
hdl->Release();
|
|
hdl = nullptr;
|
|
}
|
|
}
|
|
|
|
AudioDevice::AudioDevice()
|
|
: hdl(nullptr), client(nullptr), playbackClient(nullptr), captureClient(nullptr)
|
|
{
|
|
}
|
|
|
|
AudioDevice::AudioDevice(AudioDevice&& device) noexcept
|
|
: BaseAudioDevice(device), hdl(device.hdl), client(device.client), playbackClient(device.playbackClient),
|
|
captureClient(device.captureClient)
|
|
{
|
|
device.hdl = nullptr;
|
|
device.client = nullptr;
|
|
device.playbackClient = nullptr;
|
|
device.captureClient = nullptr;
|
|
}
|
|
|
|
AudioDevice::AudioDevice(const AudioDevice& device)
|
|
: BaseAudioDevice(device), hdl(nullptr), client(nullptr), playbackClient(nullptr),
|
|
captureClient(nullptr)
|
|
{
|
|
}
|
|
|
|
AudioDevice& AudioDevice::operator=(AudioDevice&& device) noexcept
|
|
{
|
|
if (this == &device)
|
|
return *this;
|
|
|
|
BaseAudioDevice::operator=(device);
|
|
|
|
hdl = device.hdl;
|
|
client = device.client;
|
|
playbackClient = device.playbackClient;
|
|
captureClient = device.captureClient;
|
|
|
|
device.hdl = nullptr;
|
|
device.client = nullptr;
|
|
device.playbackClient = nullptr;
|
|
device.captureClient = nullptr;
|
|
|
|
return *this;
|
|
}
|
|
|
|
AudioDevice& AudioDevice::operator=(const AudioDevice& device)
|
|
{
|
|
if (this == &device)
|
|
return *this;
|
|
|
|
BaseAudioDevice::operator=(device);
|
|
|
|
hdl = nullptr;
|
|
client = nullptr;
|
|
playbackClient = nullptr;
|
|
captureClient = nullptr;
|
|
|
|
return *this;
|
|
}
|
|
|
|
void AudioDevice::OpenStream()
|
|
{
|
|
if (IsStreaming())
|
|
return;
|
|
|
|
HRESULT r = hdl->Activate(__uuidof(IAudioClient), CLSCTX_ALL, nullptr, (void**)&client);
|
|
if (FAILED(r))
|
|
EHS_LOG_INT(LogType::ERR, 0, "Failed to create audio client with error #" + Str_8::FromNum(r) + ".");
|
|
|
|
WAVEFORMATEXTENSIBLE* format;
|
|
client->GetMixFormat((WAVEFORMATEX**)&format);
|
|
|
|
if (byteDepth)
|
|
{
|
|
if (dataType == DataType::FLOAT)
|
|
format->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
|
|
else
|
|
format->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
|
|
|
|
format->Format.wBitsPerSample = byteDepth * 8;
|
|
}
|
|
else
|
|
{
|
|
if (format->SubFormat == KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)
|
|
dataType = DataType::FLOAT;
|
|
else
|
|
dataType = FromAudioBitDepth(format->Format.wBitsPerSample);
|
|
|
|
byteDepth = format->Format.wBitsPerSample / 8;
|
|
}
|
|
|
|
if (sampleRate)
|
|
format->Format.nSamplesPerSec = sampleRate;
|
|
else
|
|
sampleRate = format->Format.nSamplesPerSec;
|
|
|
|
if (channels)
|
|
format->Format.nChannels = channels;
|
|
else
|
|
channels = format->Format.nChannels;
|
|
|
|
format->Format.nBlockAlign = byteDepth * channels;
|
|
format->Format.nAvgBytesPerSec = format->Format.nBlockAlign * sampleRate;
|
|
|
|
WAVEFORMATEX* match = {};
|
|
r = client->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED, (WAVEFORMATEX*)format, &match);
|
|
if (FAILED(r))
|
|
{
|
|
if (r == AUDCLNT_E_UNSUPPORTED_FORMAT)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 1,
|
|
"The audio device, \"" + GetName_8() + "\" doesn't support the format {" +
|
|
Str_8::FromNum(format->Format.wBitsPerSample) + "-bit, " +
|
|
Str_8::FromNum(format->Format.nSamplesPerSec) + "Hz, " +
|
|
Str_8::FromNum(format->Format.nChannels) + " Channels}."
|
|
);
|
|
}
|
|
else
|
|
EHS_LOG_INT(LogType::ERR, 2, "Failed to retrieve supported audio format with error #" + Str_8::FromNum(r) + ".");
|
|
|
|
return;
|
|
}
|
|
|
|
if (match)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 3,
|
|
"The audio device, \"" + GetName_8() + "\" doesn't support the format {" +
|
|
Str_8::FromNum(format->Format.wBitsPerSample) + "-bit, " +
|
|
Str_8::FromNum(format->Format.nSamplesPerSec) + "Hz, " +
|
|
Str_8::FromNum(format->Format.nChannels) + " Channels}. Closest format, {" +
|
|
Str_8::FromNum(match->wBitsPerSample) + "-bit Max, " +
|
|
Str_8::FromNum(match->nSamplesPerSec) + "Hz Max, " +
|
|
Str_8::FromNum(match->nChannels) + " Channels Min}."
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
r = client->Initialize(
|
|
AUDCLNT_SHAREMODE_SHARED,
|
|
0,
|
|
latency * 10,
|
|
period * 10,
|
|
(WAVEFORMATEX*)format,
|
|
nullptr
|
|
);
|
|
|
|
if (r == AUDCLNT_E_ALREADY_INITIALIZED)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 5, "Audio client is already initialized.");
|
|
return;
|
|
}
|
|
else if (r == AUDCLNT_E_WRONG_ENDPOINT_TYPE)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 6, "The AUDCLNT_STREAMFLAGS_LOOPBACK flag is set but the endpoint device is a capture device, not a rendering device.");
|
|
return;
|
|
}
|
|
else if (r == AUDCLNT_E_BUFFER_SIZE_ERROR)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 7, "Indicates that the buffer duration value requested by an exclusive-mode client is out of range. The requested duration value for pull mode must not be greater than 5000 milliseconds; for push mode the duration value must not be greater than 2 seconds.");
|
|
return;
|
|
}
|
|
else if (r == AUDCLNT_E_CPUUSAGE_EXCEEDED)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 8, "The audio endpoint device has been unplugged, or the audio hardware or associated hardware resources have been reconfigured, disabled, removed, or otherwise made unavailable for use.");
|
|
return;
|
|
}
|
|
else if (r == AUDCLNT_E_DEVICE_IN_USE)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 9, "The endpoint device is already in use. Either the device is being used in exclusive mode, or the device is being used in shared mode and the caller asked to use the device in exclusive mode.");
|
|
return;
|
|
}
|
|
else if (r == AUDCLNT_E_ENDPOINT_CREATE_FAILED)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 10, "The method failed to create the audio endpoint for the render or the capture device. This can occur if the audio endpoint device has been unplugged, or the audio hardware or associated hardware resources have been reconfigured, disabled, removed, or otherwise made unavailable for use.");
|
|
return;
|
|
}
|
|
else if (r == AUDCLNT_E_INVALID_DEVICE_PERIOD)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 11, "Indicates that the device period requested by an exclusive-mode client is greater than 5000 milliseconds.");
|
|
return;
|
|
}
|
|
else if (r == AUDCLNT_E_UNSUPPORTED_FORMAT)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 12, "The audio engine (shared mode) or audio endpoint device (exclusive mode) does not support the specified format.");
|
|
return;
|
|
}
|
|
else if (r == AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 13, "The caller is requesting exclusive-mode use of the endpoint device, but the user has disabled exclusive-mode use of the device.");
|
|
return;
|
|
}
|
|
else if (r == AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 14, "The AUDCLNT_STREAMFLAGS_EVENTCALLBACK flag is set but parameters hnsBufferDuration and hnsPeriodicity are not equal.");
|
|
return;
|
|
}
|
|
else if (r == AUDCLNT_E_SERVICE_NOT_RUNNING)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 15, "The Windows audio service is not running.");
|
|
return;
|
|
}
|
|
else if (r == E_POINTER)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 16, "Parameter pFormat is NULL.");
|
|
return;
|
|
}
|
|
else if (r == E_INVALIDARG)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 17, "Parameter pFormat points to an invalid format description; or the AUDCLNT_STREAMFLAGS_LOOPBACK flag is set but ShareMode is not equal to AUDCLNT_SHAREMODE_SHARED; or the AUDCLNT_STREAMFLAGS_CROSSPROCESS flag is set but ShareMode is equal to AUDCLNT_SHAREMODE_EXCLUSIVE.\n"
|
|
"A prior call to SetClientProperties was made with an invalid category for audio/render streams.");
|
|
return;
|
|
}
|
|
else if (r == E_OUTOFMEMORY)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 18, "Out of memory.");
|
|
return;
|
|
}
|
|
else if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 19, "Failed to initialize audio stream with error #" + Str_8::FromNum(r) + ".");
|
|
return;
|
|
}
|
|
|
|
if (type == AudioDeviceType::OUTPUT)
|
|
{
|
|
r = client->GetService(__uuidof(IAudioRenderClient), (void**)&playbackClient);
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 27, "Failed to retrieve audio render client with error #" + Str_8::FromNum(r) + ".");
|
|
return;
|
|
}
|
|
}
|
|
else if (type == AudioDeviceType::INPUT)
|
|
{
|
|
r = client->GetService(__uuidof(IAudioCaptureClient), (void**)&captureClient);
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 28, "Failed to retrieve audio capture client with error #" + Str_8::FromNum(r) + ".");
|
|
return;
|
|
}
|
|
}
|
|
|
|
r = client->GetBufferSize((UINT32*)&maxFrames);
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 29, "Failed to retrieve buffer size with error #" + Str_8::FromNum(r) + ".");
|
|
return;
|
|
}
|
|
|
|
r = client->Start();
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 30, "Failed to start audio with error #" + Str_8::FromNum(r) + ".");
|
|
return;
|
|
}
|
|
|
|
EHS_LOG_SUCCESS();
|
|
}
|
|
|
|
void AudioDevice::CloseStream()
|
|
{
|
|
if (!IsStreaming())
|
|
return;
|
|
|
|
if (playbackClient)
|
|
{
|
|
playbackClient->Release();
|
|
playbackClient = nullptr;
|
|
}
|
|
|
|
if (captureClient)
|
|
{
|
|
captureClient->Release();
|
|
captureClient = nullptr;
|
|
}
|
|
|
|
if (hdl)
|
|
{
|
|
HRESULT r = client->Stop();
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 0, "Failed to stop audio with error #" + Str_8::FromNum(r) + ".");
|
|
return;
|
|
}
|
|
|
|
client->Release();
|
|
client = nullptr;
|
|
|
|
hdl->Release();
|
|
hdl = nullptr;
|
|
}
|
|
|
|
EHS_LOG_SUCCESS();
|
|
}
|
|
|
|
UInt_64 AudioDevice::SendStream(const void *data, UInt_64 outFrameSize)
|
|
{
|
|
if (!IsValid() || !IsStreaming() || !playbackClient || !data || !outFrameSize)
|
|
return 0;
|
|
|
|
UInt_32 frameOffset = 0;
|
|
|
|
HRESULT r = client->GetCurrentPadding(&frameOffset);
|
|
if (r == AUDCLNT_E_DEVICE_INVALIDATED)
|
|
{
|
|
EHS_LOG_INT(LogType::WARN, 0, "The audio device has been invalidated.");
|
|
return 0;
|
|
}
|
|
else if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 1, "Failed to retrieve samples padding with error #" + Str_8::FromNum(r) + ".");
|
|
return 0;
|
|
}
|
|
|
|
UInt_32 frameSize = maxFrames - frameOffset;
|
|
if (frameSize > outFrameSize)
|
|
frameSize = outFrameSize;
|
|
|
|
Byte *buffer = nullptr;
|
|
|
|
r = playbackClient->GetBuffer(frameSize, &buffer);
|
|
if (r == AUDCLNT_E_DEVICE_INVALIDATED)
|
|
{
|
|
EHS_LOG_INT(LogType::WARN, 2, "The audio device has been invalidated.");
|
|
return 0;
|
|
}
|
|
else if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 3, "Failed to retrieve buffer with error #" + Str_8::FromNum(r) + ".");
|
|
return 0;
|
|
}
|
|
|
|
Util::Copy(buffer, data, frameSize * byteDepth * channels);
|
|
|
|
r = playbackClient->ReleaseBuffer(frameSize, 0);
|
|
if (r == AUDCLNT_E_DEVICE_INVALIDATED)
|
|
{
|
|
EHS_LOG_INT(LogType::WARN, 4, "The audio device has been invalidated.");
|
|
return 0;
|
|
}
|
|
else if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 5, "Failed to release buffer with error #" + Str_8::FromNum(r) + ".");
|
|
return 0;
|
|
}
|
|
|
|
return frameSize;
|
|
}
|
|
|
|
UInt_64 AudioDevice::ReceiveStream(void *data, UInt_64 inFrameSize)
|
|
{
|
|
if (!IsValid() || !IsStreaming() || !captureClient || !data || !inFrameSize)
|
|
return 0;
|
|
|
|
UInt_32 frameSize = 0;
|
|
HRESULT r = captureClient->GetNextPacketSize(&frameSize);
|
|
if (r == AUDCLNT_E_DEVICE_INVALIDATED)
|
|
{
|
|
EHS_LOG_INT(LogType::WARN, 0, "The audio device has been invalidated.");
|
|
return 0;
|
|
}
|
|
else if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 1, "Failed to retrieve samples size with error #" + Str_8::FromNum(r) + ".");
|
|
return 0;
|
|
}
|
|
|
|
if (frameSize > inFrameSize)
|
|
frameSize = inFrameSize;
|
|
|
|
UInt_64 frameOffset = 0;
|
|
r = client->GetCurrentPadding((UINT32*)&frameOffset);
|
|
if (r == AUDCLNT_E_DEVICE_INVALIDATED)
|
|
{
|
|
EHS_LOG_INT(LogType::WARN, 2, "The audio device has been invalidated.");
|
|
return 0;
|
|
}
|
|
else if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 3, "Failed to retrieve samples padding with error #" + Str_8::FromNum(r) + ".");
|
|
return 0;
|
|
}
|
|
|
|
UInt_32 flags = 0;
|
|
Byte* buffer = nullptr;
|
|
|
|
r = captureClient->GetBuffer(&buffer, (UINT32*)&frameSize, (DWORD*)&flags, nullptr, nullptr);
|
|
if (r == AUDCLNT_E_DEVICE_INVALIDATED)
|
|
{
|
|
EHS_LOG_INT(LogType::WARN, 4, "The audio device has been invalidated.");
|
|
return 0;
|
|
}
|
|
else if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 5, "Failed to retrieve buffer with error #" + Str_8::FromNum(r) + ".");
|
|
return 0;
|
|
}
|
|
|
|
Util::Copy(data, &buffer[frameOffset], frameSize * byteDepth * channels);
|
|
|
|
r = captureClient->ReleaseBuffer(frameSize);
|
|
if (r == AUDCLNT_E_DEVICE_INVALIDATED)
|
|
{
|
|
EHS_LOG_INT(LogType::WARN, 6, "The audio device has been invalidated.");
|
|
return 0;
|
|
}
|
|
else if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 7, "Failed to release buffer with error #" + Str_8::FromNum(r) + ".");
|
|
return 0;
|
|
}
|
|
|
|
EHS_LOG_SUCCESS();
|
|
|
|
return frameSize;
|
|
}
|
|
|
|
Str_32 AudioDevice::GetInterfaceName_32() const
|
|
{
|
|
return UTF::To_32(GetInterfaceName_16());
|
|
}
|
|
|
|
Str_16 AudioDevice::GetInterfaceName_16() const
|
|
{
|
|
IPropertyStore* pProps = nullptr;
|
|
HRESULT r = hdl->OpenPropertyStore(STGM_READ, &pProps);
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 0, "Failed to retrieve interface name with error #" + Str_8::FromNum(r) + ".");
|
|
return nullptr;
|
|
}
|
|
|
|
PROPVARIANT varName = {};
|
|
PropVariantInit(&varName);
|
|
|
|
pProps->GetValue(PKEY_DeviceInterface_FriendlyName, &varName);
|
|
|
|
Str_16 name((wchar_t*)varName.pwszVal);
|
|
|
|
PropVariantClear(&varName);
|
|
pProps->Release();
|
|
|
|
return name;
|
|
}
|
|
|
|
Str_8 AudioDevice::GetInterfaceName_8() const
|
|
{
|
|
return UTF::To_8(GetInterfaceName_16());
|
|
}
|
|
|
|
Str_32 AudioDevice::GetName_32() const
|
|
{
|
|
return UTF::To_32(GetName_16());
|
|
}
|
|
|
|
Str_16 AudioDevice::GetName_16() const
|
|
{
|
|
IPropertyStore* pProps = nullptr;
|
|
HRESULT r = hdl->OpenPropertyStore(STGM_READ, &pProps);
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 0, "Failed to retrieve name with error #" + Str_8::FromNum(r) + ".");
|
|
return nullptr;
|
|
}
|
|
|
|
PROPVARIANT varName = {};
|
|
PropVariantInit(&varName);
|
|
|
|
pProps->GetValue(PKEY_Device_FriendlyName, &varName);
|
|
|
|
Str_16 name((wchar_t*)varName.pwszVal);
|
|
|
|
PropVariantClear(&varName);
|
|
pProps->Release();
|
|
|
|
return name;
|
|
}
|
|
|
|
Str_8 AudioDevice::GetName_8() const
|
|
{
|
|
return UTF::To_8(GetName_16());
|
|
}
|
|
|
|
bool AudioDevice::IsStreaming() const
|
|
{
|
|
return hdl && client && (playbackClient || captureClient);
|
|
}
|
|
|
|
bool AudioDevice::IsValid() const
|
|
{
|
|
return hdl;
|
|
}
|
|
|
|
AudioDevice AudioDevice::GetDefault(const AudioDeviceType type)
|
|
{
|
|
AudioDevice result;
|
|
|
|
HRESULT r = CoInitialize(nullptr);
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 0, "Failed to initialize COM with error #" + Str_8::FromNum(r) + ".");
|
|
return result;
|
|
}
|
|
|
|
IMMDeviceEnumerator* enumerator = nullptr;
|
|
r = CoCreateInstance(__uuidof(MMDeviceEnumerator), nullptr, CLSCTX_ALL, __uuidof(IMMDeviceEnumerator), (void**)&enumerator);
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 1, "Failed to initialize WASAPI with error #" + Str_8::FromNum(r) + ".");
|
|
return result;
|
|
}
|
|
|
|
IMMDevice* deviceHdl = nullptr;
|
|
r = enumerator->GetDefaultAudioEndpoint((EDataFlow)type, eConsole, &deviceHdl);
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 2, "Failed to retrieve default audio output device with error #" + Str_8::FromNum(r) + ".");
|
|
return result;
|
|
}
|
|
|
|
result.hdl = deviceHdl;
|
|
result.type = type;
|
|
|
|
enumerator->Release();
|
|
|
|
return result;
|
|
}
|
|
|
|
Array<AudioDevice> AudioDevice::Get(const AudioDeviceType type, const AudioDeviceState state)
|
|
{
|
|
Array<AudioDevice> devices;
|
|
|
|
HRESULT r = CoInitialize(nullptr);
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 0, "Failed to initialize COM with error #" + Str_8::FromNum(r) + ".");
|
|
return devices;
|
|
}
|
|
|
|
IMMDeviceEnumerator* enumerator = nullptr;
|
|
r = CoCreateInstance(__uuidof(MMDeviceEnumerator), nullptr, CLSCTX_ALL, __uuidof(IMMDeviceEnumerator), (void**)&enumerator);
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 1, "Failed to initialize WASAPI with error #" + Str_8::FromNum(r) + ".");
|
|
return devices;
|
|
}
|
|
|
|
IMMDeviceCollection* collection = nullptr;
|
|
r = enumerator->EnumAudioEndpoints((EDataFlow)type, (DWORD)state, &collection);
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 2, "Failed to retrieve audio device collection with error #" + Str_8::FromNum(r) + ".");
|
|
return devices;
|
|
}
|
|
|
|
UInt_32 count = 0;
|
|
r = collection->GetCount((UINT*)&count);
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 3, "Failed to retrieve audio device count with error #" + Str_8::FromNum(r) + ".");
|
|
return devices;
|
|
}
|
|
|
|
devices.Resize(count);
|
|
for (UInt_32 i = 0; i < count; ++i)
|
|
{
|
|
IMMDevice* deviceHdl = nullptr;
|
|
r = collection->Item(i, &deviceHdl);
|
|
if (FAILED(r))
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 4, "Failed to retrieve audio device with error #" + Str_8::FromNum(r) + ".");
|
|
return devices;
|
|
}
|
|
|
|
devices[i].hdl = deviceHdl;
|
|
devices[i].type = type;
|
|
}
|
|
|
|
enumerator->Release();
|
|
|
|
return devices;
|
|
}
|
|
} |