std::string CAESinkDirectSound::GetDefaultDevice() { IMMDeviceEnumerator* pEnumerator = NULL; IMMDevice* pDevice = NULL; IPropertyStore* pProperty = NULL; HRESULT hr; PROPVARIANT varName; std::string strDevName = "default"; hr = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void**)&pEnumerator); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Could not allocate WASAPI device enumerator. CoCreateInstance error code: %s", WASAPIErrToStr(hr)); goto failed; } hr = pEnumerator->GetDefaultAudioEndpoint(eRender, eMultimedia, &pDevice); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of audio endpoint enumeration failed."); goto failed; } hr = pDevice->OpenPropertyStore(STGM_READ, &pProperty); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint properties failed."); goto failed; } PropVariantInit(&varName); hr = pProperty->GetValue(PKEY_AudioEndpoint_FormFactor, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint form factor failed."); goto failed; } AEDeviceType aeDeviceType = winEndpoints[(EndpointFormFactor)varName.uiVal].aeDeviceType; PropVariantClear(&varName); hr = pProperty->GetValue(PKEY_AudioEndpoint_GUID, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint GUID failed."); goto failed; } strDevName = localWideToUtf(varName.pwszVal); PropVariantClear(&varName); failed: SAFE_RELEASE(pProperty); SAFE_RELEASE(pDevice); SAFE_RELEASE(pEnumerator); return strDevName; }
// Private method // dwKeyName means: // 0 DeviceDesc (main name) // 1 DeviceInterface_FriendlyName (interface name) // 2 Device_FriendlyName (main name + interface name) void _GetDeviceName(IMMDevice *pDevice, LPWSTR pszBuffer, int bufferLen, DWORD dwKeyName) { static const WCHAR szDefault[] = L"<Device not available>"; HRESULT hr = E_FAIL; IPropertyStore *pProps = NULL; PROPVARIANT varName; // Initialize container for property value. PropVariantInit(&varName); // assert(pszBuffer != NULL); // assert(bufferLen > 0); // assert(dwKeyName == 0 || dwKeyName == 1 || dwKeyName == 2); if (pDevice != NULL) { hr = pDevice->OpenPropertyStore(STGM_READ, &pProps); if (hr == S_OK) { switch (dwKeyName) { case 0: hr = pProps->GetValue(PKEY_Device_DeviceDesc, &varName); break; case 1: hr = pProps->GetValue(PKEY_DeviceInterface_FriendlyName, &varName); break; case 2: hr = pProps->GetValue(PKEY_Device_FriendlyName, &varName); break; } } } if (hr == S_OK) { // Found the device name. wcsncpy_s(pszBuffer, bufferLen, varName.pwszVal, _TRUNCATE); } else { // Failed to find the device name. wcsncpy_s(pszBuffer, bufferLen, szDefault, _TRUNCATE); } PropVariantClear(&varName); SAFE_RELEASE(pProps); return; }
// // Retrieves the device friendly name for a particular device in a device collection. // // The returned string was allocated using malloc() so it should be freed using free(); // String GetDeviceName(IMMDeviceCollection *DeviceCollection, UINT DeviceIndex) { IMMDevice *device; LPWSTR deviceId; HRESULT hr; hr = DeviceCollection->Item(DeviceIndex, &device); PersistentAssert(SUCCEEDED(hr), "DeviceCollection->Item failed"); hr = device->GetId(&deviceId); PersistentAssert(SUCCEEDED(hr), "device->GetId failed"); IPropertyStore *propertyStore; hr = device->OpenPropertyStore(STGM_READ, &propertyStore); SafeRelease(&device); PersistentAssert(SUCCEEDED(hr), "device->OpenPropertyStore failed"); PROPVARIANT friendlyName; PropVariantInit(&friendlyName); hr = propertyStore->GetValue(PKEY_Device_FriendlyName, &friendlyName); SafeRelease(&propertyStore); PersistentAssert(SUCCEEDED(hr), "propertyStore->GetValue failed"); String Result = String(UnicodeString(friendlyName.pwszVal)); // + String(" (") + String( UnicodeString(deviceId) ) + String(")") PropVariantClear(&friendlyName); CoTaskMemFree(deviceId); return Result; }
static HRESULT DeviceNameGet( IMMDeviceCollection *dc, UINT id, wchar_t *name, size_t nameBytes) { HRESULT hr = 0; IMMDevice *device = nullptr; LPWSTR deviceId = nullptr; IPropertyStore *ps = nullptr; PROPVARIANT pv; assert(dc); assert(name); name[0] = 0; assert(0 < nameBytes); PropVariantInit(&pv); HRR(dc->Item(id, &device)); HRR(device->GetId(&deviceId)); HRR(device->OpenPropertyStore(STGM_READ, &ps)); HRG(ps->GetValue(PKEY_Device_FriendlyName, &pv)); SafeRelease(&ps); wcsncpy_s(name, nameBytes / sizeof name[0], pv.pwszVal, _TRUNCATE); end: PropVariantClear(&pv); CoTaskMemFree(deviceId); SafeRelease(&ps); return hr; }
HRESULT CPlayer::GetBufferProgress( DWORD *pProgress ) { IPropertyStore *pProp = NULL; PROPVARIANT var; // Get the property store from the media session. HRESULT hr = MFGetService( m_pSession, MFNETSOURCE_STATISTICS_SERVICE, IID_PPV_ARGS( &pProp ) ); if ( SUCCEEDED( hr ) ) { PROPERTYKEY key; key.fmtid = MFNETSOURCE_STATISTICS; key.pid = MFNETSOURCE_BUFFERPROGRESS_ID; hr = pProp->GetValue( key, &var ); } if ( SUCCEEDED( hr ) ) { *pProgress = var.lVal; // cout << "buff prog " << *pProgress << endl; } PropVariantClear( &var ); SafeRelease( &pProp ); return hr; }
// ---------------------------------------------------------------------------- // AudioVolumeController* AudioVolumeController::createVolumeController( ) { HRESULT hr; IMMDeviceEnumerator *pEnumerator = NULL; IMMDevice *pDefaultDevice = NULL; IAudioEndpointVolume *endpointVolume = NULL; LPWSTR pstrDefaultId = NULL; IPropertyStore *pProperties = NULL; try { hr = CoCreateInstance( CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void**)&pEnumerator); AUDIO_VOLUME_ASSERT( hr, "Cannot create COM device enumerator instance" ); // Get the default audio endpoint (if we don't get one its not an error) hr = pEnumerator->GetDefaultAudioEndpoint( eRender, eConsole, &pDefaultDevice ); AUDIO_VOLUME_ASSERT( hr, "Cannot get default audio render device" ); hr = pDefaultDevice->OpenPropertyStore( STGM_READ, &pProperties ); AUDIO_VOLUME_ASSERT( hr, "Cannot open IMMDevice property store" ); PROPVARIANT varName; // Initialize container for property value. PropVariantInit(&varName); // Get the endpoint's friendly-name property. hr = pProperties->GetValue( PKEY_Device_DeviceDesc , &varName); AUDIO_VOLUME_ASSERT( hr, "Cannot open IMMDevice name property" ); CString render_name = CW2A( varName.pwszVal ); DMXStudio::log_status( "Default audio render device '%s'", render_name ); PropVariantClear(&varName); hr = pDefaultDevice->Activate( IID_IAudioEndpointVolume, CLSCTX_INPROC_SERVER, NULL, (LPVOID *)&endpointVolume ); AUDIO_VOLUME_ASSERT( hr, "Cannot activate default render device" ); SAFE_RELEASE( pDefaultDevice ); SAFE_RELEASE( pProperties ); SAFE_RELEASE( pEnumerator ); CoTaskMemFree( pstrDefaultId ); return new AudioVolumeController( endpointVolume, render_name ); } catch ( ... ) { CoTaskMemFree( pstrDefaultId ); SAFE_RELEASE( pDefaultDevice ); SAFE_RELEASE( pProperties ); SAFE_RELEASE( pEnumerator ); throw; } }
// // Retrieves the device friendly name for a particular device in a device collection. // LPWSTR GetDeviceName(IMMDeviceCollection *DeviceCollection, UINT DeviceIndex) { IMMDevice *device; LPWSTR deviceId; HRESULT hr; hr = DeviceCollection->Item(DeviceIndex, &device); if (FAILED(hr)) { printf("Unable to get device %d: %x\n", DeviceIndex, hr); return NULL; } hr = device->GetId(&deviceId); if (FAILED(hr)) { printf("Unable to get device %d id: %x\n", DeviceIndex, hr); return NULL; } IPropertyStore *propertyStore; hr = device->OpenPropertyStore(STGM_READ, &propertyStore); SafeRelease(&device); if (FAILED(hr)) { printf("Unable to open device %d property store: %x\n", DeviceIndex, hr); return NULL; } PROPVARIANT friendlyName; PropVariantInit(&friendlyName); hr = propertyStore->GetValue(PKEY_Device_FriendlyName, &friendlyName); SafeRelease(&propertyStore); if (FAILED(hr)) { printf("Unable to retrieve friendly name for device %d : %x\n", DeviceIndex, hr); return NULL; } wchar_t deviceName[128]; hr = StringCbPrintf(deviceName, sizeof(deviceName), L"%s (%s)", friendlyName.vt != VT_LPWSTR ? L"Unknown" : friendlyName.pwszVal, deviceId); if (FAILED(hr)) { printf("Unable to format friendly name for device %d : %x\n", DeviceIndex, hr); return NULL; } PropVariantClear(&friendlyName); CoTaskMemFree(deviceId); wchar_t *returnValue = _wcsdup(deviceName); if (returnValue == NULL) { printf("Unable to allocate buffer for return\n"); return NULL; } return returnValue; }
PLUGIN_EXPORT LPCWSTR GetString(void* data) { static WCHAR result[256]; wsprintf(result, L"ERROR"); if (!InitCom() || !pEnumerator) { UnInitCom(); wsprintf(result, L"ERROR - Initializing COM"); return result; } IMMDevice * pEndpoint = 0; if (pEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &pEndpoint) == S_OK) { IPropertyStore * pProps = 0; if (pEndpoint->OpenPropertyStore(STGM_READ, &pProps) == S_OK) { PROPVARIANT varName; PropVariantInit(&varName); if (pProps->GetValue(PKEY_Device_DeviceDesc, &varName) == S_OK) { wcsncpy(result, varName.pwszVal, 255); PropVariantClear(&varName); SAFE_RELEASE(pProps) SAFE_RELEASE(pEndpoint) UnInitCom(); return result; } else { PropVariantClear(&varName); SAFE_RELEASE(pProps) SAFE_RELEASE(pEndpoint) wsprintf(result, L"ERROR - Getting Device Description"); } } else { SAFE_RELEASE(pProps) SAFE_RELEASE(pEndpoint) wsprintf(result, L"ERROR - Getting Property"); } } else { SAFE_RELEASE(pEndpoint) wsprintf(result, L"ERROR - Getting Default Device"); } UnInitCom(); return result; }
const QHash<QString, QString> WASAPISystem::getDevices(EDataFlow dataflow) { QHash<QString, QString> devices; HRESULT hr; IMMDeviceEnumerator *pEnumerator = NULL; IMMDeviceCollection *pCollection = NULL; hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_ALL, __uuidof(IMMDeviceEnumerator), reinterpret_cast<void **>(&pEnumerator)); if (! pEnumerator || FAILED(hr)) { qWarning("WASAPI: Failed to instatiate enumerator"); } else { hr = pEnumerator->EnumAudioEndpoints(dataflow, DEVICE_STATE_ACTIVE, &pCollection); if (! pCollection || FAILED(hr)) { qWarning("WASAPI: Failed to enumerate"); } else { devices.insert(QString(), tr("Default Device")); UINT ndev = 0; pCollection->GetCount(&ndev); for (unsigned int idx=0;idx<ndev;++idx) { IMMDevice *pDevice = NULL; IPropertyStore *pStore = NULL; pCollection->Item(idx, &pDevice); pDevice->OpenPropertyStore(STGM_READ, &pStore); LPWSTR strid = NULL; pDevice->GetId(&strid); PROPVARIANT varName; PropVariantInit(&varName); pStore->GetValue(PKEY_Device_FriendlyName, &varName); devices.insert(QString::fromWCharArray(strid), QString::fromWCharArray(varName.pwszVal)); PropVariantClear(&varName); CoTaskMemFree(strid); pStore->Release(); pDevice->Release(); } pCollection->Release(); } pEnumerator->Release(); } return devices; }
HRESULT GetAudioDeviceDetails(_In_ IMMDevice* immDevice, _Out_ AudioDevice* pInfo) { IPropertyStore *propStore = nullptr; PROPVARIANT varName; PROPVARIANT varId; PropVariantInit(&varId); PropVariantInit(&varName); HRESULT hResult = immDevice->OpenPropertyStore(STGM_READ, &propStore); if (SUCCEEDED(hResult)) { hResult = propStore->GetValue(PKEY_AudioEndpoint_Path, &varId); } if (SUCCEEDED(hResult)) { hResult = propStore->GetValue(PKEY_Device_FriendlyName, &varName); } if (SUCCEEDED(hResult)) { assert(varId.vt == VT_LPWSTR); assert(varName.vt == VT_LPWSTR); // Now save somewhere the device display name & id pInfo->name = varName.pwszVal; pInfo->id = varId.pwszVal; } PropVariantClear(&varName); PropVariantClear(&varId); if (propStore != nullptr) { propStore->Release(); } return hResult; }
static void GetDeviceInfo(IMMDevice *pDevice, MFDevice *pDev) { wchar_t *pWC; pDevice->GetId(&pWC); MFString_CopyUTF16ToUTF8(pDev->strings[MFDS_ID], pWC); CoTaskMemFree(pWC); DWORD state; pDevice->GetState(&state); UpdateState(pDev, state); IPropertyStore *pProps; pDevice->OpenPropertyStore(STGM_READ, &pProps); PROPVARIANT v; PropVariantInit(&v); pProps->GetValue(PKEY_DeviceInterface_FriendlyName, &v); MFString_CopyUTF16ToUTF8(pDev->strings[MFDS_InterfaceName], v.pwszVal); PropVariantClear(&v); PropVariantInit(&v); pProps->GetValue(PKEY_Device_DeviceDesc, &v); MFString_CopyUTF16ToUTF8(pDev->strings[MFDS_Description], v.pwszVal); PropVariantClear(&v); PropVariantInit(&v); pProps->GetValue(PKEY_Device_FriendlyName, &v); MFString_CopyUTF16ToUTF8(pDev->strings[MFDS_DeviceName], v.pwszVal); PropVariantClear(&v); PropVariantInit(&v); pProps->GetValue(PKEY_Device_Manufacturer, &v); MFString_CopyUTF16ToUTF8(pDev->strings[MFDS_Manufacturer], v.pwszVal ? v.pwszVal : L""); PropVariantClear(&v); pProps->Release(); }
LPWSTR GetDeviceName(IMMDeviceCollection *DeviceCollection, UINT DeviceIndex) { IMMDevice *device; LPWSTR deviceId; HRESULT hr; hr = DeviceCollection->Item(DeviceIndex, &device); if (FAILED(hr)) { printf("Unable to get device %d: %x\n", DeviceIndex, hr); return nullptr; } hr = device->GetId(&deviceId); if (FAILED(hr)) { printf("Unable to get device %d id: %x\n", DeviceIndex, hr); return nullptr; } IPropertyStore *propertyStore; hr = device->OpenPropertyStore(STGM_READ, &propertyStore); if (FAILED(hr)) { printf("Unable to open device %d property store: %x\n", DeviceIndex, hr); return nullptr; } PROPVARIANT friendlyName; PropVariantInit(&friendlyName); hr = propertyStore->GetValue(PKEY_Device_FriendlyName, &friendlyName); if (FAILED(hr)) { printf("Unable to retrieve friendly name for device %d : %x\n", DeviceIndex, hr); return nullptr; } DVAR(friendlyName.vt); if (friendlyName.vt != VT_LPWSTR) DVAR("Unknown"); else DVAR((const wchar_t *)friendlyName.pwszVal); PropVariantClear(&friendlyName); CoTaskMemFree(deviceId); return nullptr; }
Array AudioDriverWASAPI::audio_device_get_list(bool p_capture) { Array list; IMMDeviceCollection *devices = NULL; IMMDeviceEnumerator *enumerator = NULL; list.push_back(String("Default")); CoInitialize(NULL); HRESULT hr = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void **)&enumerator); ERR_FAIL_COND_V(hr != S_OK, Array()); hr = enumerator->EnumAudioEndpoints(p_capture ? eCapture : eRender, DEVICE_STATE_ACTIVE, &devices); ERR_FAIL_COND_V(hr != S_OK, Array()); UINT count = 0; hr = devices->GetCount(&count); ERR_FAIL_COND_V(hr != S_OK, Array()); for (ULONG i = 0; i < count; i++) { IMMDevice *device = NULL; hr = devices->Item(i, &device); ERR_BREAK(hr != S_OK); IPropertyStore *props = NULL; hr = device->OpenPropertyStore(STGM_READ, &props); ERR_BREAK(hr != S_OK); PROPVARIANT propvar; PropVariantInit(&propvar); hr = props->GetValue(PKEY_Device_FriendlyName, &propvar); ERR_BREAK(hr != S_OK); list.push_back(String(propvar.pwszVal)); PropVariantClear(&propvar); props->Release(); device->Release(); } devices->Release(); enumerator->Release(); return list; }
HRESULT GetPropertyValueForArray(PCWSTR pszFilename, PCWSTR pszCanonicalName,char*value) { // Convert the Canonical name of the property to PROPERTYKEY PROPERTYKEY key; HRESULT hr = PSGetPropertyKeyFromName(pszCanonicalName, &key); if (SUCCEEDED(hr)) { IPropertyStore* pps = NULL; // Call the helper to get the property store for the initialized item hr = GetPropertyStore(pszFilename, GPS_DEFAULT, &pps); if (SUCCEEDED(hr)) { PROPVARIANT propvarValue = { 0 }; HRESULT hr = pps->GetValue(key, &propvarValue); if (SUCCEEDED(hr)) { PWSTR pszDisplayValue = NULL; hr = PSFormatForDisplayAlloc(key, propvarValue, PDFF_DEFAULT, &pszDisplayValue); if (SUCCEEDED(hr)) { wprintf(L"%s = %s\n", pszCanonicalName, pszDisplayValue); if (value!= NULL) { WideCharToMultiByte(CP_OEMCP, 0, pszDisplayValue, -1, value, 1000, NULL, FALSE); } CoTaskMemFree(pszDisplayValue); } PropVariantClear(&propvarValue); } //return hr; //hr = PrintProperty(pps, key, pszCanonicalName); pps->Release(); } else { wprintf(L"Error %x: getting the propertystore for the item.\n", hr); } } else { wprintf(L"Invalid property specified: %s\n", pszCanonicalName); } return hr; }
static void addDeviceSelectorItem(QComboBox *const deviceSelector, IMMDevice *const pEndpoint) { LPWSTR pwszID = 0; IPropertyStore *pProps = 0; pEndpoint->GetId(&pwszID); pEndpoint->OpenPropertyStore(STGM_READ, &pProps); if (pwszID && pProps) { PROPVARIANT varName; std::memset(&varName, 0, sizeof varName); if (SUCCEEDED(pProps->GetValue(PKEY_Device_FriendlyName, &varName))) { deviceSelector->addItem(QString::fromWCharArray(varName.pwszVal), QVariant::fromValue(std::wstring(pwszID))); CoTaskMemFree(varName.pwszVal); //PropVariantClear(&varName); } CoTaskMemFree(pwszID); pProps->Release(); } }
static int getPhotoOrientation(const LPWSTR lpszPath) { int nRet = 0; IPropertyStore* pps = NULL; WCHAR szExpanded[MAX_PATH]; HRESULT hr = ExpandEnvironmentStrings(lpszPath, szExpanded, ARRAYSIZE(szExpanded)) ? S_OK : HRESULT_FROM_WIN32(GetLastError()); if (SUCCEEDED(hr)) { WCHAR szAbsPath[MAX_PATH]; hr = _wfullpath(szAbsPath, szExpanded, ARRAYSIZE(szAbsPath)) ? S_OK : E_FAIL; if (SUCCEEDED(hr)) { hr = SHGetPropertyStoreFromParsingName(szAbsPath, NULL, GPS_DEFAULT, IID_PPV_ARGS(&pps)); if (SUCCEEDED(hr)) { PROPVARIANT propvarValue = {0}; PROPERTYKEY key; hr = PSGetPropertyKeyFromName(PropertyKey_Orientation, &key); if (SUCCEEDED(hr)) { hr = pps->GetValue(key, &propvarValue); if (SUCCEEDED(hr)) { nRet = propvarValue.uintVal; } } PropVariantClear(&propvarValue); } } } if (pps) { pps->Release(); } return nRet; }
String MMDeviceAudioSource::GetDeviceName() { IPropertyStore *store; if(SUCCEEDED(mmDevice->OpenPropertyStore(STGM_READ, &store))) { PROPVARIANT varName; PropVariantInit(&varName); if(SUCCEEDED(store->GetValue(PKEY_Device_FriendlyName, &varName))) { CWSTR wstrName = varName.pwszVal; String strName = wstrName; return strName; } store->Release(); } return String(TEXT("(could not query name of device)")); }
//得到设备硬件ID (设备管理器可以看到的硬件ID) bool CCoreAudioVolume::GetDeviceDsc(IMMDevice *pDevice,wchar_t* DeviceDsc) { HRESULT hr; IPropertyStore *pStore; hr = pDevice->OpenPropertyStore(STGM_READ, &pStore); if (SUCCEEDED(hr)) { PROPERTYKEY Drvidkey = {0xb3f8fa53, 0x0004, 0x438e, 0x90, 0x03, 0x51, 0xa4, 0x6e, 0x13, 0x9b, 0xfc, 2}; PROPVARIANT pDrvidkey; PropVariantInit(&pDrvidkey); hr = pStore->GetValue(Drvidkey , &pDrvidkey); if (SUCCEEDED(hr)) { wcscpy(DeviceDsc,pDrvidkey.pwszVal); PropVariantClear(&pDrvidkey); pStore->Release(); return true; } pStore->Release(); } return false; }
HRESULT CMpcAudioRenderer::GetAudioDevice(IMMDevice **ppMMDevice) { TRACE(_T("CMpcAudioRenderer::GetAudioDevice\n")); CComPtr<IMMDeviceEnumerator> enumerator; IMMDeviceCollection* devices; IPropertyStore* pProps = NULL; HRESULT hr = enumerator.CoCreateInstance(__uuidof(MMDeviceEnumerator)); if (hr != S_OK) { TRACE(_T("CMpcAudioRenderer::GetAudioDevice - failed to create MMDeviceEnumerator!\n")); return hr; } TRACE(_T("CMpcAudioRenderer::GetAudioDevice - Target end point: %s\n"), m_csSound_Device); if (GetAvailableAudioDevices(&devices) == S_OK && devices) { UINT count(0); hr = devices->GetCount(&count); if (hr != S_OK) { TRACE(_T("CMpcAudioRenderer::GetAudioDevice - devices->GetCount failed: (0x%08x)\n"), hr); return hr; } for (ULONG i = 0 ; i < count ; i++) { LPWSTR pwszID = NULL; IMMDevice *endpoint = NULL; hr = devices->Item(i, &endpoint); if (hr == S_OK) { hr = endpoint->GetId(&pwszID); if (hr == S_OK) { if (endpoint->OpenPropertyStore(STGM_READ, &pProps) == S_OK) { PROPVARIANT varName; PropVariantInit(&varName); // Found the configured audio endpoint if ((pProps->GetValue(PKEY_Device_FriendlyName, &varName) == S_OK) && (m_csSound_Device == varName.pwszVal)) { TRACE(_T("CMpcAudioRenderer::GetAudioDevice - devices->GetId OK, num: (%d), pwszVal: %s, pwszID: %s\n"), i, varName.pwszVal, pwszID); enumerator->GetDevice(pwszID, ppMMDevice); SAFE_RELEASE(devices); *(ppMMDevice) = endpoint; CoTaskMemFree(pwszID); pwszID = NULL; PropVariantClear(&varName); SAFE_RELEASE(pProps); return S_OK; } else { PropVariantClear(&varName); SAFE_RELEASE(pProps); SAFE_RELEASE(endpoint); CoTaskMemFree(pwszID); pwszID = NULL; } } } else { TRACE(_T("CMpcAudioRenderer::GetAudioDevice - devices->GetId failed: (0x%08x)\n"), hr); } } else { TRACE(_T("CMpcAudioRenderer::GetAudioDevice - devices->Item failed: (0x%08x)\n"), hr); } CoTaskMemFree(pwszID); pwszID = NULL; } } TRACE(_T("CMpcAudioRenderer::GetAudioDevice - Unable to find selected audio device, using the default end point!\n")); hr = enumerator->GetDefaultAudioEndpoint(eRender, eConsole, ppMMDevice); SAFE_RELEASE(devices); return hr; }
bool CWin32WASAPI::Initialize(IAudioCallback* pCallback, const CStdString& device, int iChannels, enum PCMChannels *channelMap, unsigned int uiSamplesPerSec, unsigned int uiBitsPerSample, bool bResample, bool bIsMusic, bool bAudioPassthrough) { CLog::Log(LOGDEBUG, __FUNCTION__": endpoint device %s", device.c_str()); //First check if the version of Windows we are running on even supports WASAPI. if (!g_sysinfo.IsVistaOrHigher()) { CLog::Log(LOGERROR, __FUNCTION__": WASAPI output requires Vista or higher."); return false; } //Only one exclusive stream may be initialized at one time. if(m_bIsAllocated) { CLog::Log(LOGERROR, __FUNCTION__": Cannot create more then one WASAPI stream at one time."); return false; } int layoutChannels = 0; if(!bAudioPassthrough) { //If no channel map is specified, use the default. if(!channelMap) channelMap = (PCMChannels *)wasapi_default_channel_layout[iChannels - 1]; PCMChannels *outLayout = m_remap.SetInputFormat(iChannels, channelMap, uiBitsPerSample / 8); for(PCMChannels *channel = outLayout; *channel != PCM_INVALID; channel++) ++layoutChannels; //Expand monural to stereo as most devices don't seem to like 1 channel PCM streams. //Stereo sources should be sent explicitly as two channels so that the external hardware //can apply ProLogic/5CH Stereo/etc processing on it. if(iChannels <= 2) { BuildChannelMapping(2, (PCMChannels *)wasapi_default_channel_layout[1]); layoutChannels = 2; m_remap.SetOutputFormat(2, m_SpeakerOrder, false); } else //Do the standard remapping. { BuildChannelMapping(layoutChannels, outLayout); m_remap.SetOutputFormat(layoutChannels, m_SpeakerOrder, false); } } m_bPlaying = false; m_bPause = false; m_bMuting = false; m_uiChannels = iChannels; m_uiBitsPerSample = uiBitsPerSample; m_bPassthrough = bAudioPassthrough; m_nCurrentVolume = g_settings.m_nVolumeLevel; m_pcmAmplifier.SetVolume(m_nCurrentVolume); WAVEFORMATEXTENSIBLE wfxex = {0}; //fill waveformatex ZeroMemory(&wfxex, sizeof(WAVEFORMATEXTENSIBLE)); wfxex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX); wfxex.Format.nChannels = layoutChannels; wfxex.Format.nSamplesPerSec = uiSamplesPerSec; if (bAudioPassthrough == true) { wfxex.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT; wfxex.Format.wFormatTag = WAVE_FORMAT_DOLBY_AC3_SPDIF; wfxex.SubFormat = _KSDATAFORMAT_SUBTYPE_DOLBY_AC3_SPDIF; wfxex.Format.wBitsPerSample = 16; wfxex.Format.nChannels = 2; } else { wfxex.dwChannelMask = m_uiSpeakerMask; wfxex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE; wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_PCM; wfxex.Format.wBitsPerSample = uiBitsPerSample; } wfxex.Samples.wValidBitsPerSample = uiBitsPerSample == 32 ? 24 : uiBitsPerSample; wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3); wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign; m_uiAvgBytesPerSec = wfxex.Format.nAvgBytesPerSec; m_uiBytesPerFrame = wfxex.Format.nBlockAlign; m_uiBytesPerSrcFrame = bAudioPassthrough ? m_uiBytesPerFrame : iChannels * wfxex.Format.wBitsPerSample >> 3; IMMDeviceEnumerator* pEnumerator = NULL; IMMDeviceCollection* pEnumDevices = NULL; //Shut down Directsound. g_audioContext.SetActiveDevice(CAudioContext::NONE); HRESULT hr = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void**)&pEnumerator); EXIT_ON_FAILURE(hr, __FUNCTION__": Could not allocate WASAPI device enumerator. CoCreateInstance error code: %i", hr) //Get our device. //First try to find the named device. UINT uiCount = 0; hr = pEnumerator->EnumAudioEndpoints(eRender, DEVICE_STATE_ACTIVE, &pEnumDevices); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of audio endpoint enumeration failed.") hr = pEnumDevices->GetCount(&uiCount); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of audio endpoint count failed.") for(UINT i = 0; i < uiCount; i++) { IPropertyStore *pProperty = NULL; PROPVARIANT varName; hr = pEnumDevices->Item(i, &m_pDevice); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of WASAPI endpoint failed.") hr = m_pDevice->OpenPropertyStore(STGM_READ, &pProperty); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of WASAPI endpoint properties failed.") hr = pProperty->GetValue(PKEY_Device_FriendlyName, &varName); if(FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of WASAPI endpoint device name failed."); SAFE_RELEASE(pProperty); goto failed; } CStdStringW strRawDevName(varName.pwszVal); CStdString strDevName; g_charsetConverter.wToUTF8(strRawDevName, strDevName); if(device == strDevName) i = uiCount; else SAFE_RELEASE(m_pDevice); PropVariantClear(&varName); SAFE_RELEASE(pProperty); } SAFE_RELEASE(pEnumDevices); if(!m_pDevice) { CLog::Log(LOGDEBUG, __FUNCTION__": Could not locate the device named \"%s\" in the list of WASAPI endpoint devices. Trying the default device...", device.c_str()); hr = pEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &m_pDevice); EXIT_ON_FAILURE(hr, __FUNCTION__": Could not retrieve the default WASAPI audio endpoint.") }
void CAESinkDirectSound::EnumerateDevicesEx(AEDeviceInfoList &deviceInfoList, bool force) { CAEDeviceInfo deviceInfo; IMMDeviceEnumerator* pEnumerator = NULL; IMMDeviceCollection* pEnumDevices = NULL; HRESULT hr; std::string strDD = GetDefaultDevice(); /* Windows Vista or later - supporting WASAPI device probing */ hr = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void**)&pEnumerator); EXIT_ON_FAILURE(hr, __FUNCTION__": Could not allocate WASAPI device enumerator. CoCreateInstance error code: %li", hr) UINT uiCount = 0; hr = pEnumerator->EnumAudioEndpoints(eRender, DEVICE_STATE_ACTIVE, &pEnumDevices); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of audio endpoint enumeration failed.") hr = pEnumDevices->GetCount(&uiCount); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of audio endpoint count failed.") for (UINT i = 0; i < uiCount; i++) { IMMDevice *pDevice = NULL; IPropertyStore *pProperty = NULL; PROPVARIANT varName; PropVariantInit(&varName); deviceInfo.m_channels.Reset(); deviceInfo.m_dataFormats.clear(); deviceInfo.m_sampleRates.clear(); hr = pEnumDevices->Item(i, &pDevice); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint failed."); goto failed; } hr = pDevice->OpenPropertyStore(STGM_READ, &pProperty); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint properties failed."); SAFE_RELEASE(pDevice); goto failed; } hr = pProperty->GetValue(PKEY_Device_FriendlyName, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint device name failed."); SAFE_RELEASE(pDevice); SAFE_RELEASE(pProperty); goto failed; } std::string strFriendlyName = localWideToUtf(varName.pwszVal); PropVariantClear(&varName); hr = pProperty->GetValue(PKEY_AudioEndpoint_GUID, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint GUID failed."); SAFE_RELEASE(pDevice); SAFE_RELEASE(pProperty); goto failed; } std::string strDevName = localWideToUtf(varName.pwszVal); PropVariantClear(&varName); hr = pProperty->GetValue(PKEY_AudioEndpoint_FormFactor, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint form factor failed."); SAFE_RELEASE(pDevice); SAFE_RELEASE(pProperty); goto failed; } std::string strWinDevType = winEndpoints[(EndpointFormFactor)varName.uiVal].winEndpointType; AEDeviceType aeDeviceType = winEndpoints[(EndpointFormFactor)varName.uiVal].aeDeviceType; PropVariantClear(&varName); /* In shared mode Windows tells us what format the audio must be in. */ IAudioClient *pClient; hr = pDevice->Activate(IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&pClient); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Activate device failed (%s)", WASAPIErrToStr(hr)); goto failed; } //hr = pClient->GetMixFormat(&pwfxex); hr = pProperty->GetValue(PKEY_AudioEngine_DeviceFormat, &varName); if (SUCCEEDED(hr) && varName.blob.cbSize > 0) { WAVEFORMATEX* smpwfxex = (WAVEFORMATEX*)varName.blob.pBlobData; deviceInfo.m_channels = layoutsByChCount[std::max(std::min(smpwfxex->nChannels, (WORD) DS_SPEAKER_COUNT), (WORD) 2)]; deviceInfo.m_dataFormats.push_back(AEDataFormat(AE_FMT_FLOAT)); deviceInfo.m_dataFormats.push_back(AEDataFormat(AE_FMT_AC3)); deviceInfo.m_sampleRates.push_back(std::min(smpwfxex->nSamplesPerSec, (DWORD) 192000)); } else { CLog::Log(LOGERROR, __FUNCTION__": Getting DeviceFormat failed (%s)", WASAPIErrToStr(hr)); } pClient->Release(); SAFE_RELEASE(pDevice); SAFE_RELEASE(pProperty); deviceInfo.m_deviceName = strDevName; deviceInfo.m_displayName = strWinDevType.append(strFriendlyName); deviceInfo.m_displayNameExtra = std::string("DirectSound: ").append(strFriendlyName); deviceInfo.m_deviceType = aeDeviceType; deviceInfoList.push_back(deviceInfo); // add the default device with m_deviceName = default if(strDD == strDevName) { deviceInfo.m_deviceName = std::string("default"); deviceInfo.m_displayName = std::string("default"); deviceInfo.m_displayNameExtra = std::string(""); deviceInfoList.push_back(deviceInfo); } } return; failed: if (FAILED(hr)) CLog::Log(LOGERROR, __FUNCTION__": Failed to enumerate WASAPI endpoint devices (%s).", WASAPIErrToStr(hr)); SAFE_RELEASE(pEnumDevices); SAFE_RELEASE(pEnumerator); }
bool MMDeviceAudioSource::Initialize(bool bMic, CTSTR lpID) { const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator); const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator); const IID IID_IAudioClient = __uuidof(IAudioClient); const IID IID_IAudioCaptureClient = __uuidof(IAudioCaptureClient); HRESULT err; err = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void**)&mmEnumerator); if(FAILED(err)) { AppWarning(TEXT("MMDeviceAudioSource::Initialize(%d): Could not create IMMDeviceEnumerator = %08lX"), (BOOL)bMic, err); return false; } bIsMic = bMic; if (bIsMic) { BOOL bMicSyncFixHack = GlobalConfig->GetInt(TEXT("Audio"), TEXT("UseMicSyncFixHack")); angerThreshold = bMicSyncFixHack ? 40 : 1000; } if (scmpi(lpID, TEXT("Default")) == 0) err = mmEnumerator->GetDefaultAudioEndpoint(bMic ? eCapture : eRender, bMic ? eCommunications : eConsole, &mmDevice); else err = mmEnumerator->GetDevice(lpID, &mmDevice); if(FAILED(err)) { AppWarning(TEXT("MMDeviceAudioSource::Initialize(%d): Could not create IMMDevice = %08lX"), (BOOL)bMic, err); return false; } err = mmDevice->Activate(IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&mmClient); if(FAILED(err)) { AppWarning(TEXT("MMDeviceAudioSource::Initialize(%d): Could not create IAudioClient = %08lX"), (BOOL)bMic, err); return false; } //----------------------------------------------------------------- // get name IPropertyStore *store; if(SUCCEEDED(mmDevice->OpenPropertyStore(STGM_READ, &store))) { PROPVARIANT varName; PropVariantInit(&varName); if(SUCCEEDED(store->GetValue(PKEY_Device_FriendlyName, &varName))) { CWSTR wstrName = varName.pwszVal; strDeviceName = wstrName; } store->Release(); } if(bMic) { Log(TEXT("------------------------------------------")); Log(TEXT("Using auxilary audio input: %s"), GetDeviceName()); bUseQPC = GlobalConfig->GetInt(TEXT("Audio"), TEXT("UseMicQPC")) != 0; if (bUseQPC) Log(TEXT("Using Mic QPC timestamps")); } else { Log(TEXT("------------------------------------------")); Log(TEXT("Using desktop audio input: %s"), GetDeviceName()); bUseVideoTime = AppConfig->GetInt(TEXT("Audio"), TEXT("SyncToVideoTime")) != 0; SetTimeOffset(GlobalConfig->GetInt(TEXT("Audio"), TEXT("GlobalAudioTimeAdjust"))); } //----------------------------------------------------------------- // get format WAVEFORMATEX *pwfx; err = mmClient->GetMixFormat(&pwfx); if(FAILED(err)) { AppWarning(TEXT("MMDeviceAudioSource::Initialize(%d): Could not get mix format from audio client = %08lX"), (BOOL)bMic, err); return false; } bool bFloat; UINT inputChannels; UINT inputSamplesPerSec; UINT inputBitsPerSample; UINT inputBlockSize; DWORD inputChannelMask = 0; WAVEFORMATEXTENSIBLE *wfext = NULL; //the internal audio engine should always use floats (or so I read), but I suppose just to be safe better check if(pwfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE) { wfext = (WAVEFORMATEXTENSIBLE*)pwfx; inputChannelMask = wfext->dwChannelMask; if(wfext->SubFormat != KSDATAFORMAT_SUBTYPE_IEEE_FLOAT) { AppWarning(TEXT("MMDeviceAudioSource::Initialize(%d): Unsupported wave format"), (BOOL)bMic); return false; } } else if(pwfx->wFormatTag != WAVE_FORMAT_IEEE_FLOAT) { AppWarning(TEXT("MMDeviceAudioSource::Initialize(%d): Unsupported wave format"), (BOOL)bMic); return false; } bFloat = true; inputChannels = pwfx->nChannels; inputBitsPerSample = 32; inputBlockSize = pwfx->nBlockAlign; inputSamplesPerSec = pwfx->nSamplesPerSec; sampleWindowSize = (inputSamplesPerSec/100); DWORD flags = bMic ? 0 : AUDCLNT_STREAMFLAGS_LOOPBACK; err = mmClient->Initialize(AUDCLNT_SHAREMODE_SHARED, flags, ConvertMSTo100NanoSec(5000), 0, pwfx, NULL); //err = AUDCLNT_E_UNSUPPORTED_FORMAT; if (err == AUDCLNT_E_UNSUPPORTED_FORMAT) { //workaround for razer kraken headset (bad drivers) pwfx->nBlockAlign = 2*pwfx->nChannels; pwfx->nAvgBytesPerSec = inputSamplesPerSec*pwfx->nBlockAlign; pwfx->wBitsPerSample = 16; wfext->SubFormat = KSDATAFORMAT_SUBTYPE_PCM; wfext->Samples.wValidBitsPerSample = 16; bConvert = true; err = mmClient->Initialize(AUDCLNT_SHAREMODE_SHARED, flags, ConvertMSTo100NanoSec(5000), 0, pwfx, NULL); } if(FAILED(err)) { AppWarning(TEXT("MMDeviceAudioSource::Initialize(%d): Could not initialize audio client, result = %08lX"), (BOOL)bMic, err); return false; } //----------------------------------------------------------------- // acquire services err = mmClient->GetService(IID_IAudioCaptureClient, (void**)&mmCapture); if(FAILED(err)) { AppWarning(TEXT("MMDeviceAudioSource::Initialize(%d): Could not get audio capture client, result = %08lX"), (BOOL)bMic, err); return false; } err = mmClient->GetService(__uuidof(IAudioClock), (void**)&mmClock); if(FAILED(err)) { AppWarning(TEXT("MMDeviceAudioSource::Initialize(%d): Could not get audio capture clock, result = %08lX"), (BOOL)bMic, err); return false; } CoTaskMemFree(pwfx); //----------------------------------------------------------------- InitAudioData(bFloat, inputChannels, inputSamplesPerSec, inputBitsPerSample, inputBlockSize, inputChannelMask); return true; }
void CAESinkDirectSound::EnumerateDevicesEx(AEDeviceInfoList &deviceInfoList, bool force) { CAEDeviceInfo deviceInfo; IMMDeviceEnumerator* pEnumerator = NULL; IMMDeviceCollection* pEnumDevices = NULL; HRESULT hr; /* See if we are on Windows XP */ if (!g_sysinfo.IsWindowsVersionAtLeast(CSysInfo::WindowsVersionVista)) { /* We are on XP - WASAPI not supported - enumerate using DS devices */ LPGUID deviceGUID = NULL; RPC_CSTR cszGUID; std::string szGUID; std::list<DSDevice> DSDeviceList; DirectSoundEnumerate(DSEnumCallback, &DSDeviceList); for(std::list<DSDevice>::iterator itt = DSDeviceList.begin(); itt != DSDeviceList.end(); ++itt) { if (UuidToString((*itt).lpGuid, &cszGUID) != RPC_S_OK) continue; /* could not convert GUID to string - skip device */ deviceInfo.m_channels.Reset(); deviceInfo.m_dataFormats.clear(); deviceInfo.m_sampleRates.clear(); szGUID = (LPSTR)cszGUID; deviceInfo.m_deviceName = "{" + szGUID + "}"; deviceInfo.m_displayName = (*itt).name; deviceInfo.m_displayNameExtra = std::string("DirectSound: ") + (*itt).name; deviceInfo.m_deviceType = AE_DEVTYPE_PCM; deviceInfo.m_channels = layoutsByChCount[2]; deviceInfo.m_dataFormats.push_back(AEDataFormat(AE_FMT_FLOAT)); deviceInfo.m_dataFormats.push_back(AEDataFormat(AE_FMT_AC3)); deviceInfo.m_sampleRates.push_back((DWORD) 96000); deviceInfoList.push_back(deviceInfo); } RpcStringFree(&cszGUID); return; } /* Windows Vista or later - supporting WASAPI device probing */ hr = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void**)&pEnumerator); EXIT_ON_FAILURE(hr, __FUNCTION__": Could not allocate WASAPI device enumerator. CoCreateInstance error code: %li", hr) UINT uiCount = 0; hr = pEnumerator->EnumAudioEndpoints(eRender, DEVICE_STATE_ACTIVE, &pEnumDevices); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of audio endpoint enumeration failed.") hr = pEnumDevices->GetCount(&uiCount); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of audio endpoint count failed.") for (UINT i = 0; i < uiCount; i++) { IMMDevice *pDevice = NULL; IPropertyStore *pProperty = NULL; PROPVARIANT varName; PropVariantInit(&varName); deviceInfo.m_channels.Reset(); deviceInfo.m_dataFormats.clear(); deviceInfo.m_sampleRates.clear(); hr = pEnumDevices->Item(i, &pDevice); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint failed."); goto failed; } hr = pDevice->OpenPropertyStore(STGM_READ, &pProperty); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint properties failed."); SAFE_RELEASE(pDevice); goto failed; } hr = pProperty->GetValue(PKEY_Device_FriendlyName, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint device name failed."); SAFE_RELEASE(pDevice); SAFE_RELEASE(pProperty); goto failed; } std::string strFriendlyName = localWideToUtf(varName.pwszVal); PropVariantClear(&varName); hr = pProperty->GetValue(PKEY_AudioEndpoint_GUID, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint GUID failed."); SAFE_RELEASE(pDevice); SAFE_RELEASE(pProperty); goto failed; } std::string strDevName = localWideToUtf(varName.pwszVal); PropVariantClear(&varName); hr = pProperty->GetValue(PKEY_AudioEndpoint_FormFactor, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of DirectSound endpoint form factor failed."); SAFE_RELEASE(pDevice); SAFE_RELEASE(pProperty); goto failed; } std::string strWinDevType = winEndpoints[(EndpointFormFactor)varName.uiVal].winEndpointType; AEDeviceType aeDeviceType = winEndpoints[(EndpointFormFactor)varName.uiVal].aeDeviceType; PropVariantClear(&varName); /* In shared mode Windows tells us what format the audio must be in. */ IAudioClient *pClient; hr = pDevice->Activate(IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&pClient); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Activate device failed (%s)", WASAPIErrToStr(hr)); goto failed; } //hr = pClient->GetMixFormat(&pwfxex); hr = pProperty->GetValue(PKEY_AudioEngine_DeviceFormat, &varName); if (SUCCEEDED(hr) && varName.blob.cbSize > 0) { WAVEFORMATEX* smpwfxex = (WAVEFORMATEX*)varName.blob.pBlobData; deviceInfo.m_channels = layoutsByChCount[std::max(std::min(smpwfxex->nChannels, (WORD) DS_SPEAKER_COUNT), (WORD) 2)]; deviceInfo.m_dataFormats.push_back(AEDataFormat(AE_FMT_FLOAT)); deviceInfo.m_dataFormats.push_back(AEDataFormat(AE_FMT_AC3)); deviceInfo.m_sampleRates.push_back(std::min(smpwfxex->nSamplesPerSec, (DWORD) 192000)); } else { CLog::Log(LOGERROR, __FUNCTION__": Getting DeviceFormat failed (%s)", WASAPIErrToStr(hr)); } pClient->Release(); SAFE_RELEASE(pDevice); SAFE_RELEASE(pProperty); deviceInfo.m_deviceName = strDevName; deviceInfo.m_displayName = strWinDevType.append(strFriendlyName); deviceInfo.m_displayNameExtra = std::string("DirectSound: ").append(strFriendlyName); deviceInfo.m_deviceType = aeDeviceType; deviceInfoList.push_back(deviceInfo); } // since AE takes the first device in deviceInfoList as default audio device we need // to sort it in order to use the real default device if(deviceInfoList.size() > 1) { std::string strDD = GetDefaultDevice(); for (AEDeviceInfoList::iterator itt = deviceInfoList.begin(); itt != deviceInfoList.end(); ++itt) { CAEDeviceInfo devInfo = *itt; if(devInfo.m_deviceName == strDD) { deviceInfoList.erase(itt); deviceInfoList.insert(deviceInfoList.begin(), devInfo); break; } } } return; failed: if (FAILED(hr)) CLog::Log(LOGERROR, __FUNCTION__": Failed to enumerate WASAPI endpoint devices (%s).", WASAPIErrToStr(hr)); SAFE_RELEASE(pEnumDevices); SAFE_RELEASE(pEnumerator); }
TBool OhmSenderDriverWindows::FindEndpoint(const char* aManufacturer) { bool uninitialise = true; HRESULT hr = CoInitialize(NULL); printf("CoInitialize %d\n", hr); if (hr == 0x80010106) { uninitialise = false; } else if (!SUCCEEDED(hr)) { return (false); } // Create a multimedia device enumerator. hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_ALL, __uuidof(IMMDeviceEnumerator), (void**)&iDeviceEnumerator); printf("CoCreateInstance %d\n", hr); if (SUCCEEDED(hr)) { IMMDeviceCollection *pDevices; // Enumerate the output devices. hr = iDeviceEnumerator->EnumAudioEndpoints(eRender, DEVICE_STATEMASK_ALL | 0x10000000, &pDevices); printf("EnumAudioEndpoints %d\n", hr); if (SUCCEEDED(hr)) { UINT count; pDevices->GetCount(&count); printf("count: %d\n", count); if (SUCCEEDED(hr)) { for (unsigned i = 0; i < count; i++) { IMMDevice *pDevice; hr = pDevices->Item(i, &pDevice); if (SUCCEEDED(hr)) { LPWSTR wstrID = NULL; hr = pDevice->GetId(&wstrID); wprintf(L"id: %s\n", wstrID); if (SUCCEEDED(hr)) { IPropertyStore *pStore; hr = pDevice->OpenPropertyStore(STGM_READ, &pStore); if (SUCCEEDED(hr)) { PROPVARIANT var; PropVariantInit(&var); hr = pStore->GetValue(PKEY_AudioEndpoint_GUID, &var); wprintf(L"%s\n", var.pwszVal); PROPVARIANT friendlyName; PropVariantInit(&friendlyName); hr = pStore->GetValue(PKEY_DeviceInterface_FriendlyName, &friendlyName); wprintf(L"friendlyName: %s\n", friendlyName.pwszVal); if (SUCCEEDED(hr)) { wchar_t model[200]; MultiByteToWideChar(CP_ACP, 0, aManufacturer, -1, model, sizeof(model)); wcscpy(model + wcslen(model), L" Songcast"); if (!wcscmp(friendlyName.pwszVal, model)) { iSongcastEndpoint.Set(wstrID); PropVariantClear(&friendlyName); pStore->Release(); pDevice->Release(); pDevices->Release(); if (uninitialise) { CoUninitialize(); } return (true); } PropVariantClear(&friendlyName); } pStore->Release(); } CoTaskMemFree(wstrID); } pDevice->Release(); } } } pDevices->Release(); } iDeviceEnumerator->Release(); } if (uninitialise) { CoUninitialize(); } return (false); }
bool CAESinkWASAPI::Initialize(AEAudioFormat &format, std::string &device) { if (m_initialized) return false; m_device = device; bool bdefault = false; /* Save requested format */ /* Clear returned format */ sinkReqFormat = format.m_dataFormat; sinkRetFormat = AE_FMT_INVALID; IMMDeviceEnumerator* pEnumerator = NULL; IMMDeviceCollection* pEnumDevices = NULL; HRESULT hr = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void**)&pEnumerator); EXIT_ON_FAILURE(hr, __FUNCTION__": Could not allocate WASAPI device enumerator. CoCreateInstance error code: %li", hr) /* Get our device. First try to find the named device. */ UINT uiCount = 0; hr = pEnumerator->EnumAudioEndpoints(eRender, DEVICE_STATE_ACTIVE, &pEnumDevices); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of audio endpoint enumeration failed.") hr = pEnumDevices->GetCount(&uiCount); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of audio endpoint count failed.") if(StringUtils::EndsWithNoCase(device, std::string("default"))) bdefault = true; if(!bdefault) { for (UINT i = 0; i < uiCount; i++) { IPropertyStore *pProperty = NULL; PROPVARIANT varName; hr = pEnumDevices->Item(i, &m_pDevice); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of WASAPI endpoint failed.") hr = m_pDevice->OpenPropertyStore(STGM_READ, &pProperty); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of WASAPI endpoint properties failed.") hr = pProperty->GetValue(PKEY_AudioEndpoint_GUID, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of WASAPI endpoint GUID failed."); SAFE_RELEASE(pProperty); goto failed; } std::string strDevName = localWideToUtf(varName.pwszVal); if (device == strDevName) i = uiCount; else SAFE_RELEASE(m_pDevice); PropVariantClear(&varName); SAFE_RELEASE(pProperty); } } SAFE_RELEASE(pEnumDevices); if (!m_pDevice) { if(!bdefault) CLog::Log(LOGINFO, __FUNCTION__": Could not locate the device named \"%s\" in the list of WASAPI endpoint devices. Trying the default device...", device.c_str()); hr = pEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &m_pDevice); EXIT_ON_FAILURE(hr, __FUNCTION__": Could not retrieve the default WASAPI audio endpoint.") IPropertyStore *pProperty = NULL; PROPVARIANT varName; hr = m_pDevice->OpenPropertyStore(STGM_READ, &pProperty); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of WASAPI endpoint properties failed.") hr = pProperty->GetValue(PKEY_AudioEndpoint_GUID, &varName); device = localWideToUtf(varName.pwszVal); PropVariantClear(&varName); SAFE_RELEASE(pProperty); } SAFE_RELEASE(pEnumerator); hr = m_pDevice->Activate(IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&m_pAudioClient); EXIT_ON_FAILURE(hr, __FUNCTION__": Activating the WASAPI endpoint device failed.") if (!InitializeExclusive(format)) { CLog::Log(LOGINFO, __FUNCTION__": Could not Initialize Exclusive with that format"); goto failed; } /* get the buffer size and calculate the frames for AE */ m_pAudioClient->GetBufferSize(&m_uiBufferLen); format.m_frames = m_uiBufferLen; format.m_frameSamples = format.m_frames * format.m_channelLayout.Count(); m_format = format; sinkRetFormat = format.m_dataFormat; hr = m_pAudioClient->GetService(IID_IAudioRenderClient, (void**)&m_pRenderClient); EXIT_ON_FAILURE(hr, __FUNCTION__": Could not initialize the WASAPI render client interface.") m_needDataEvent = CreateEvent(NULL, FALSE, FALSE, NULL); hr = m_pAudioClient->SetEventHandle(m_needDataEvent); EXIT_ON_FAILURE(hr, __FUNCTION__": Could not set the WASAPI event handler."); m_initialized = true; m_isDirty = false; // allow feeding less samples than buffer size // if the device is opened exclusive and event driven, provided samples must match buffersize // ActiveAE tries to align provided samples with buffer size but cannot guarantee (e.g. transcoding) // this can be avoided by dropping the event mode which has not much benefit; SoftAE polls anyway delete [] m_pBuffer; m_pBuffer = new uint8_t[format.m_frames * format.m_frameSize]; m_bufferPtr = 0; return true; failed: CLog::Log(LOGERROR, __FUNCTION__": WASAPI initialization failed."); SAFE_RELEASE(pEnumDevices); SAFE_RELEASE(pEnumerator); SAFE_RELEASE(m_pRenderClient); SAFE_RELEASE(m_pAudioClient); SAFE_RELEASE(m_pDevice); if(m_needDataEvent) { CloseHandle(m_needDataEvent); m_needDataEvent = 0; } return false; }
void CAESinkWASAPI::EnumerateDevicesEx(AEDeviceInfoList &deviceInfoList, bool force) { IMMDeviceEnumerator* pEnumerator = NULL; IMMDeviceCollection* pEnumDevices = NULL; IMMDevice* pDefaultDevice = NULL; CAEDeviceInfo deviceInfo; CAEChannelInfo deviceChannels; LPWSTR pwszID = NULL; std::wstring wstrDDID; WAVEFORMATEXTENSIBLE wfxex = {0}; HRESULT hr; hr = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void**)&pEnumerator); EXIT_ON_FAILURE(hr, __FUNCTION__": Could not allocate WASAPI device enumerator. CoCreateInstance error code: %li", hr) UINT uiCount = 0; // get the default audio endpoint if(pEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &pDefaultDevice) == S_OK) { if(pDefaultDevice->GetId(&pwszID) == S_OK) { wstrDDID = pwszID; CoTaskMemFree(pwszID); } SAFE_RELEASE(pDefaultDevice); } // enumerate over all audio endpoints hr = pEnumerator->EnumAudioEndpoints(eRender, DEVICE_STATE_ACTIVE, &pEnumDevices); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of audio endpoint enumeration failed.") hr = pEnumDevices->GetCount(&uiCount); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of audio endpoint count failed.") for (UINT i = 0; i < uiCount; i++) { IMMDevice *pDevice = NULL; IPropertyStore *pProperty = NULL; PROPVARIANT varName; PropVariantInit(&varName); deviceInfo.m_channels.Reset(); deviceInfo.m_dataFormats.clear(); deviceInfo.m_sampleRates.clear(); hr = pEnumDevices->Item(i, &pDevice); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of WASAPI endpoint failed."); goto failed; } hr = pDevice->OpenPropertyStore(STGM_READ, &pProperty); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of WASAPI endpoint properties failed."); SAFE_RELEASE(pDevice); goto failed; } hr = pProperty->GetValue(PKEY_Device_FriendlyName, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of WASAPI endpoint device name failed."); SAFE_RELEASE(pDevice); SAFE_RELEASE(pProperty); goto failed; } std::string strFriendlyName = localWideToUtf(varName.pwszVal); PropVariantClear(&varName); hr = pProperty->GetValue(PKEY_AudioEndpoint_GUID, &varName); if(FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of WASAPI endpoint GUID failed."); SAFE_RELEASE(pDevice); SAFE_RELEASE(pProperty); goto failed; } std::string strDevName = localWideToUtf(varName.pwszVal); PropVariantClear(&varName); hr = pProperty->GetValue(PKEY_AudioEndpoint_FormFactor, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of WASAPI endpoint form factor failed."); SAFE_RELEASE(pDevice); SAFE_RELEASE(pProperty); goto failed; } std::string strWinDevType = winEndpoints[(EndpointFormFactor)varName.uiVal].winEndpointType; AEDeviceType aeDeviceType = winEndpoints[(EndpointFormFactor)varName.uiVal].aeDeviceType; PropVariantClear(&varName); hr = pProperty->GetValue(PKEY_AudioEndpoint_PhysicalSpeakers, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of WASAPI endpoint speaker layout failed."); SAFE_RELEASE(pDevice); SAFE_RELEASE(pProperty); goto failed; } unsigned int uiChannelMask = std::max(varName.uintVal, (unsigned int) KSAUDIO_SPEAKER_STEREO); deviceChannels.Reset(); for (unsigned int c = 0; c < WASAPI_SPEAKER_COUNT; c++) { if (uiChannelMask & WASAPIChannelOrder[c]) deviceChannels += AEChannelNames[c]; } PropVariantClear(&varName); IAudioClient *pClient; hr = pDevice->Activate(IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&pClient); if (SUCCEEDED(hr)) { /* Test format DTS-HD */ wfxex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX); wfxex.Format.nSamplesPerSec = 192000; wfxex.dwChannelMask = KSAUDIO_SPEAKER_7POINT1_SURROUND; wfxex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE; wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEC61937_DTS_HD; wfxex.Format.wBitsPerSample = 16; wfxex.Samples.wValidBitsPerSample = 16; wfxex.Format.nChannels = 8; wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3); wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign; hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL); if (SUCCEEDED(hr)) deviceInfo.m_dataFormats.push_back(AEDataFormat(AE_FMT_DTSHD)); /* Test format Dolby TrueHD */ wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEC61937_DOLBY_MLP; hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL); if (SUCCEEDED(hr)) deviceInfo.m_dataFormats.push_back(AEDataFormat(AE_FMT_TRUEHD)); /* Test format Dolby EAC3 */ wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEC61937_DOLBY_DIGITAL_PLUS; wfxex.Format.nChannels = 2; wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3); wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign; hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL); if (SUCCEEDED(hr)) deviceInfo.m_dataFormats.push_back(AEDataFormat(AE_FMT_EAC3)); /* Test format DTS */ wfxex.Format.nSamplesPerSec = 48000; wfxex.dwChannelMask = KSAUDIO_SPEAKER_5POINT1; wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEC61937_DTS; wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3); wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign; hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL); if (SUCCEEDED(hr)) deviceInfo.m_dataFormats.push_back(AEDataFormat(AE_FMT_DTS)); /* Test format Dolby AC3 */ wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEC61937_DOLBY_DIGITAL; hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL); if (SUCCEEDED(hr)) deviceInfo.m_dataFormats.push_back(AEDataFormat(AE_FMT_AC3)); /* Test format AAC */ wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEC61937_AAC; hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL); if (SUCCEEDED(hr)) deviceInfo.m_dataFormats.push_back(AEDataFormat(AE_FMT_AAC)); /* Test format for PCM format iteration */ wfxex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX); wfxex.dwChannelMask = KSAUDIO_SPEAKER_STEREO; wfxex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE; wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT; for (int p = AE_FMT_FLOAT; p > AE_FMT_INVALID; p--) { if (p < AE_FMT_FLOAT) wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_PCM; wfxex.Format.wBitsPerSample = CAEUtil::DataFormatToBits((AEDataFormat) p); wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3); wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign; if (p <= AE_FMT_S24NE4 && p >= AE_FMT_S24BE4) { wfxex.Samples.wValidBitsPerSample = 24; } else { wfxex.Samples.wValidBitsPerSample = wfxex.Format.wBitsPerSample; } hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL); if (SUCCEEDED(hr)) deviceInfo.m_dataFormats.push_back((AEDataFormat) p); } /* Test format for sample rate iteration */ wfxex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX); wfxex.dwChannelMask = KSAUDIO_SPEAKER_STEREO; wfxex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE; wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_PCM; wfxex.Format.wBitsPerSample = 16; wfxex.Samples.wValidBitsPerSample = 16; wfxex.Format.nChannels = 2; wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3); wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign; for (int j = 0; j < WASAPISampleRateCount; j++) { wfxex.Format.nSamplesPerSec = WASAPISampleRates[j]; wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign; hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL); if (SUCCEEDED(hr)) deviceInfo.m_sampleRates.push_back(WASAPISampleRates[j]); } /* Test format for channels iteration */ wfxex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX); wfxex.dwChannelMask = KSAUDIO_SPEAKER_STEREO; wfxex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE; wfxex.SubFormat = KSDATAFORMAT_SUBTYPE_PCM; wfxex.Format.nSamplesPerSec = 48000; wfxex.Format.wBitsPerSample = 16; wfxex.Samples.wValidBitsPerSample = 16; wfxex.Format.nChannels = 2; wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3); wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign; bool hasLpcm = false; // Try with KSAUDIO_SPEAKER_DIRECTOUT for (unsigned int k = WASAPI_SPEAKER_COUNT; k > 0; k--) { wfxex.dwChannelMask = KSAUDIO_SPEAKER_DIRECTOUT; wfxex.Format.nChannels = k; wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3); wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign; hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL); if (SUCCEEDED(hr)) { if (k > 3) // Add only multichannel LPCM { deviceInfo.m_dataFormats.push_back(AE_FMT_LPCM); hasLpcm = true; } break; } } /* Try with reported channel mask */ for (unsigned int k = WASAPI_SPEAKER_COUNT; k > 0; k--) { wfxex.dwChannelMask = uiChannelMask; wfxex.Format.nChannels = k; wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3); wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign; hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL); if (SUCCEEDED(hr)) { if ( !hasLpcm && k > 3) // Add only multichannel LPCM { deviceInfo.m_dataFormats.push_back(AE_FMT_LPCM); hasLpcm = true; } break; } } /* Try with specific speakers configurations */ for (unsigned int i = 0; i < ARRAYSIZE(layoutsList); i++) { unsigned int nmbOfCh; wfxex.dwChannelMask = ChLayoutToChMask(layoutsList[i], &nmbOfCh); wfxex.Format.nChannels = nmbOfCh; wfxex.Format.nBlockAlign = wfxex.Format.nChannels * (wfxex.Format.wBitsPerSample >> 3); wfxex.Format.nAvgBytesPerSec = wfxex.Format.nSamplesPerSec * wfxex.Format.nBlockAlign; hr = pClient->IsFormatSupported(AUDCLNT_SHAREMODE_EXCLUSIVE, &wfxex.Format, NULL); if (SUCCEEDED(hr)) { if ( deviceChannels.Count() < nmbOfCh) deviceChannels = layoutsList[i]; if ( !hasLpcm && nmbOfCh > 3) // Add only multichannel LPCM { deviceInfo.m_dataFormats.push_back(AE_FMT_LPCM); hasLpcm = true; } } } pClient->Release(); } else { CLog::Log(LOGDEBUG, __FUNCTION__": Failed to activate device for passthrough capability testing."); } deviceInfo.m_deviceName = strDevName; deviceInfo.m_displayName = strWinDevType.append(strFriendlyName); deviceInfo.m_displayNameExtra = std::string("WASAPI: ").append(strFriendlyName); deviceInfo.m_deviceType = aeDeviceType; deviceInfo.m_channels = deviceChannels; /* Store the device info */ deviceInfoList.push_back(deviceInfo); if(pDevice->GetId(&pwszID) == S_OK) { if(wstrDDID.compare(pwszID) == 0) { deviceInfo.m_deviceName = std::string("default"); deviceInfo.m_displayName = std::string("default"); deviceInfo.m_displayNameExtra = std::string(""); deviceInfoList.push_back(deviceInfo); } CoTaskMemFree(pwszID); } SAFE_RELEASE(pDevice); SAFE_RELEASE(pProperty); }
/* ======================== idSoundHardware_XAudio2::Init ======================== */ void idSoundHardware_XAudio2::Init() { cmdSystem->AddCommand( "listDevices", listDevices_f, 0, "Lists the connected sound devices", NULL ); DWORD xAudioCreateFlags = 0; // RB: not available on Windows 8 SDK #if !defined(USE_WINRT) && defined(_DEBUG) // (_WIN32_WINNT < 0x0602 /*_WIN32_WINNT_WIN8*/) && defined(_DEBUG) xAudioCreateFlags |= XAUDIO2_DEBUG_ENGINE; #endif // RB end XAUDIO2_PROCESSOR xAudioProcessor = XAUDIO2_DEFAULT_PROCESSOR; // RB: not available on Windows 8 SDK if( FAILED( XAudio2Create( &pXAudio2, xAudioCreateFlags, xAudioProcessor ) ) ) { #if !defined(USE_WINRT) && defined(_DEBUG) // (_WIN32_WINNT < 0x0602 /*_WIN32_WINNT_WIN8*/) && defined(_DEBUG) if( xAudioCreateFlags & XAUDIO2_DEBUG_ENGINE ) { // in case the debug engine isn't installed xAudioCreateFlags &= ~XAUDIO2_DEBUG_ENGINE; if( FAILED( XAudio2Create( &pXAudio2, xAudioCreateFlags, xAudioProcessor ) ) ) { idLib::FatalError( "Failed to create XAudio2 engine. Try installing the latest DirectX." ); return; } } else #endif // RB end { idLib::FatalError( "Failed to create XAudio2 engine. Try installing the latest DirectX." ); return; } } #ifdef _DEBUG XAUDIO2_DEBUG_CONFIGURATION debugConfiguration = { 0 }; debugConfiguration.TraceMask = XAUDIO2_LOG_WARNINGS; debugConfiguration.BreakMask = XAUDIO2_LOG_ERRORS; pXAudio2->SetDebugConfiguration( &debugConfiguration ); #endif // Register the sound engine callback pXAudio2->RegisterForCallbacks( &soundEngineCallback ); soundEngineCallback.hardware = this; UINT32 deviceCount = 0; DWORD outputSampleRate = 44100; // Max( (DWORD)XAUDIO2FX_REVERB_MIN_FRAMERATE, Min( (DWORD)XAUDIO2FX_REVERB_MAX_FRAMERATE, deviceDetails.OutputFormat.Format.nSamplesPerSec ) ); // RB: not available on Windows 8 SDK #if defined(USE_WINRT) //(_WIN32_WINNT >= 0x0602 /*_WIN32_WINNT_WIN8*/) IMMDeviceEnumerator* immDevEnum = nullptr; IMMDeviceCollection* immDevCollection = nullptr; IMMDevice* immDev = nullptr; std::vector<AudioDevice> vAudioDevices; HRESULT hResult = CoCreateInstance( __uuidof( MMDeviceEnumerator ), NULL, CLSCTX_ALL, __uuidof( IMMDeviceEnumerator ), ( void** ) &immDevEnum ); if( FAILED( hResult ) ) { idLib::Warning( "Failed to get audio enumerator" ); pXAudio2->Release(); pXAudio2 = NULL; return; } hResult = immDevEnum->EnumAudioEndpoints( eRender, DEVICE_STATE_ACTIVE, &immDevCollection ); if( FAILED( hResult ) ) { idLib::Warning( "Failed to get audio endpoints" ); pXAudio2->Release(); pXAudio2 = NULL; return; } hResult = immDevCollection->GetCount( &deviceCount ); if( FAILED( hResult ) ) { idLib::Warning( "No audio devices found" ); pXAudio2->Release(); pXAudio2 = NULL; return; } for( UINT i = 0; i < deviceCount; i++ ) { IPropertyStore* propStore = nullptr; PROPVARIANT varName; PROPVARIANT varId; PropVariantInit( &varId ); PropVariantInit( &varName ); hResult = immDevCollection->Item( i, &immDev ); if( SUCCEEDED( hResult ) ) { hResult = immDev->OpenPropertyStore( STGM_READ, &propStore ); } if( SUCCEEDED( hResult ) ) { hResult = propStore->GetValue( PKEY_AudioEndpoint_Path, &varId ); } if( SUCCEEDED( hResult ) ) { hResult = propStore->GetValue( PKEY_Device_FriendlyName, &varName ); } if( SUCCEEDED( hResult ) ) { assert( varId.vt == VT_LPWSTR ); assert( varName.vt == VT_LPWSTR ); // Now save somewhere the device display name & id AudioDevice ad; ad.name = varName.pwszVal; ad.id = varId.pwszVal; vAudioDevices.push_back( ad ); } PropVariantClear( &varName ); PropVariantClear( &varId ); if( propStore != nullptr ) { propStore->Release(); } if( immDev != nullptr ) { immDev->Release(); } } immDevCollection->Release(); immDevEnum->Release(); int preferredDevice = s_device.GetInteger(); if( !vAudioDevices.empty() ) { if( SUCCEEDED( pXAudio2->CreateMasteringVoice( &pMasterVoice, XAUDIO2_DEFAULT_CHANNELS, outputSampleRate, 0, vAudioDevices.at( 0 ).id.c_str(), NULL, AudioCategory_GameEffects ) ) ) { XAUDIO2_VOICE_DETAILS deviceDetails; pMasterVoice->GetVoiceDetails( &deviceDetails ); pMasterVoice->SetVolume( DBtoLinear( s_volume_dB.GetFloat() ) ); outputChannels = deviceDetails.InputChannels; DWORD win8_channelMask; pMasterVoice->GetChannelMask( &win8_channelMask ); channelMask = ( unsigned int )win8_channelMask; idLib::Printf( "Using device %s\n", vAudioDevices.at( 0 ).name ); } else { idLib::Warning( "Failed to create master voice" ); pXAudio2->Release(); pXAudio2 = NULL; return; } } #else if( pXAudio2->GetDeviceCount( &deviceCount ) != S_OK || deviceCount == 0 ) { idLib::Warning( "No audio devices found" ); pXAudio2->Release(); pXAudio2 = NULL; return; } idCmdArgs args; listDevices_f( args ); int preferredDevice = s_device.GetInteger(); if( preferredDevice < 0 || preferredDevice >= ( int )deviceCount ) { int preferredChannels = 0; for( unsigned int i = 0; i < deviceCount; i++ ) { XAUDIO2_DEVICE_DETAILS deviceDetails; if( pXAudio2->GetDeviceDetails( i, &deviceDetails ) != S_OK ) { continue; } if( deviceDetails.Role & DefaultGameDevice ) { // if we find a device the user marked as their preferred 'game' device, then always use that preferredDevice = i; preferredChannels = deviceDetails.OutputFormat.Format.nChannels; break; } if( deviceDetails.OutputFormat.Format.nChannels > preferredChannels ) { preferredDevice = i; preferredChannels = deviceDetails.OutputFormat.Format.nChannels; } } } idLib::Printf( "Using device %d\n", preferredDevice ); XAUDIO2_DEVICE_DETAILS deviceDetails; if( pXAudio2->GetDeviceDetails( preferredDevice, &deviceDetails ) != S_OK ) { // One way this could happen is if a device is removed between the loop and this line of code // Highly unlikely but possible idLib::Warning( "Failed to get device details" ); pXAudio2->Release(); pXAudio2 = NULL; return; } if( FAILED( pXAudio2->CreateMasteringVoice( &pMasterVoice, XAUDIO2_DEFAULT_CHANNELS, outputSampleRate, 0, preferredDevice, NULL ) ) ) { idLib::Warning( "Failed to create master voice" ); pXAudio2->Release(); pXAudio2 = NULL; return; } pMasterVoice->SetVolume( DBtoLinear( s_volume_dB.GetFloat() ) ); outputChannels = deviceDetails.OutputFormat.Format.nChannels; channelMask = deviceDetails.OutputFormat.dwChannelMask; #endif // #if (_WIN32_WINNT < 0x0602 /*_WIN32_WINNT_WIN8*/) idSoundVoice::InitSurround( outputChannels, channelMask ); // --------------------- // Create VU Meter Effect // --------------------- IUnknown* vuMeter = NULL; XAudio2CreateVolumeMeter( &vuMeter, 0 ); XAUDIO2_EFFECT_DESCRIPTOR descriptor; descriptor.InitialState = true; descriptor.OutputChannels = outputChannels; descriptor.pEffect = vuMeter; XAUDIO2_EFFECT_CHAIN chain; chain.EffectCount = 1; chain.pEffectDescriptors = &descriptor; pMasterVoice->SetEffectChain( &chain ); vuMeter->Release(); // --------------------- // Create VU Meter Graph // --------------------- vuMeterRMS = console->CreateGraph( outputChannels ); vuMeterPeak = console->CreateGraph( outputChannels ); // DG: make sure they're not NULL (as it's currently the case with the cegui-based console) if( vuMeterRMS && vuMeterPeak ) { vuMeterRMS->Enable( false ); vuMeterPeak->Enable( false ); memset( vuMeterPeakTimes, 0, sizeof( vuMeterPeakTimes ) ); vuMeterPeak->SetFillMode( idDebugGraph::GRAPH_LINE ); vuMeterPeak->SetBackgroundColor( idVec4( 0.0f, 0.0f, 0.0f, 0.0f ) ); vuMeterRMS->AddGridLine( 0.500f, idVec4( 0.5f, 0.5f, 0.5f, 1.0f ) ); vuMeterRMS->AddGridLine( 0.250f, idVec4( 0.5f, 0.5f, 0.5f, 1.0f ) ); vuMeterRMS->AddGridLine( 0.125f, idVec4( 0.5f, 0.5f, 0.5f, 1.0f ) ); const char* channelNames[] = { "L", "R", "C", "S", "Lb", "Rb", "Lf", "Rf", "Cb", "Ls", "Rs" }; for( int i = 0, ci = 0; ci < sizeof( channelNames ) / sizeof( channelNames[0] ); ci++ ) { if( ( channelMask & BIT( ci ) ) == 0 ) { continue; } vuMeterRMS->SetLabel( i, channelNames[ci] ); i++; } } // --------------------- // Create submix buffer // --------------------- if( FAILED( pXAudio2->CreateSubmixVoice( &pSubmixVoice, 1, outputSampleRate, 0, 0, NULL, NULL ) ) ) { idLib::FatalError( "Failed to create submix voice" ); } // XAudio doesn't really impose a maximum number of voices voices.SetNum( voices.Max() ); freeVoices.SetNum( voices.Max() ); zombieVoices.SetNum( 0 ); for( int i = 0; i < voices.Num(); i++ ) { freeVoices[i] = &voices[i]; } // RB end }
bool EnumBuiltinDevices_w64(const uint32_t deviceType, STUDIO_LINK_DEVICE_LIST* devices) { PRECONDITION_RETURN(deviceType != INVALID_DEVICE_TYPE, false); PRECONDITION_RETURN(devices != 0, false); bool result = false; HRESULT hr = CoInitialize(0); if(SUCCEEDED(hr)) { IMMDeviceEnumerator* pDeviceEnumerator = 0; hr = CoCreateInstance(CLSID_MMDeviceEnumerator, 0, CLSCTX_INPROC_SERVER, IID_IMMDeviceEnumerator, (void**)&pDeviceEnumerator); if(SUCCEEDED(hr) && (pDeviceEnumerator != 0)) { EDataFlow dataFlow = eAll; if(deviceType == HEADPHONE) { dataFlow = eRender; } else if(deviceType == MICROPHONE) { dataFlow = eCapture; } IMMDeviceCollection* pDeviceCollection = 0; hr = pDeviceEnumerator->EnumAudioEndpoints(dataFlow, DEVICE_STATE_ACTIVE, &pDeviceCollection); if(SUCCEEDED(hr) && (pDeviceCollection != 0)) { UINT deviceCount = 0; hr = pDeviceCollection->GetCount(&deviceCount); if(SUCCEEDED(hr)) { size_t foundDevices = 0; for(UINT i = 0; (i < deviceCount) && (foundDevices < deviceCount); i++) { IMMDevice* pDevice = 0; hr = pDeviceCollection->Item(i, &pDevice); if(SUCCEEDED(hr) && (pDevice != 0)) { IPropertyStore* pProperties = 0; hr = pDevice->OpenPropertyStore(STGM_READ, &pProperties); if(SUCCEEDED(hr)) { PROPVARIANT deviceFormatProperty; PropVariantInit(&deviceFormatProperty); hr = pProperties->GetValue(PKEY_AudioEngine_DeviceFormat, &deviceFormatProperty); if(SUCCEEDED(hr) && (VT_BLOB == deviceFormatProperty.vt)) { WAVEFORMATEX* deviceFormat = (WAVEFORMATEX*)deviceFormatProperty.blob.pBlobData; devices->devices[foundDevices].channelCount = deviceFormat->nChannels; devices->devices[foundDevices].sampleRate = deviceFormat->nSamplesPerSec; if((WAVE_FORMAT_EXTENSIBLE == deviceFormat->wFormatTag) && (deviceFormat->cbSize >= 22)) { //WAVEFORMATEXTENSIBLE* extensibleDeviceFormat = (WAVEFORMATEXTENSIBLE*)deviceFormat; } PropVariantClear(&deviceFormatProperty); PROPVARIANT deviceNameProperty; PropVariantInit(&deviceNameProperty); hr = pProperties->GetValue(PKEY_Device_FriendlyName, &deviceNameProperty); if(SUCCEEDED(hr)) { PWSTR deviceName = 0; hr = PropVariantToStringAlloc(deviceNameProperty, &deviceName); if(SUCCEEDED(hr)) { memset(devices->devices[foundDevices].name, 0, STUDIO_LINK_DEVICE_NAME_LENGTH); size_t numOfCharsConverted = 0; const size_t deviceNameLength = wcslen(deviceName); wcstombs_s(&numOfCharsConverted, devices->devices[foundDevices].name, STUDIO_LINK_DEVICE_NAME_LENGTH, deviceName, deviceNameLength); foundDevices++; CoTaskMemFree(deviceName); deviceName = 0; } PropVariantClear(&deviceNameProperty); } } SafeRelease(pProperties); } SafeRelease(pDevice); } } devices->deviceCount = foundDevices; } SafeRelease(pDeviceCollection); } SafeRelease(pDeviceEnumerator); } CoUninitialize(); } if(devices->deviceCount > 0) { result = true; } return result; }
RTC::ReturnCode_t RTCKinect::onActivated(RTC::UniqueId ec_id) { /** * The configured values should be reflected to the initialization process. * * m_enable_camera -> camera image * m_enable_depth -> depth image * m_player_index -> player index detection * * important: if player indexing is enabled, depth map image is limited up to 320x240 */ DWORD dwFlag = NUI_INITIALIZE_FLAG_USES_SKELETON; if(m_enable_camera) { dwFlag |= NUI_INITIALIZE_FLAG_USES_COLOR; } if(m_enable_depth) { if(m_player_index) { dwFlag |= NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX; } else { dwFlag |= NUI_INITIALIZE_FLAG_USES_DEPTH; } } HRESULT hr = NuiInitialize(dwFlag); if( FAILED( hr ) ) { std::cout << "NUI Initialize Failed." << std::endl; return RTC::RTC_ERROR; } if(m_depth_width == 640 && m_depth_height == 480 && m_enable_depth && m_player_index) { std::cout << "If PlayerIndex and Depth Map is ON, resolution should be 320X240" << std::endl; return RTC::RTC_ERROR; } NUI_IMAGE_RESOLUTION eResolution; if(m_camera_width == 640 && m_camera_height == 480) { eResolution = NUI_IMAGE_RESOLUTION_640x480; } else { std::cout << "Invalid Image Resolution" << std::endl; return RTC::RTC_ERROR; } if(m_enable_camera) { hr = NuiImageStreamOpen(::NUI_IMAGE_TYPE_COLOR, eResolution, 0, 2, NULL, &m_pVideoStreamHandle ); if( FAILED( hr ) ) { std::cout << "NUI Image Stream Open Failed." << std::endl; return RTC::RTC_ERROR; } } if(m_depth_width == 640 && m_depth_height == 480) { eResolution = NUI_IMAGE_RESOLUTION_640x480; } else if(m_depth_width == 320 && m_depth_height == 240) { eResolution = NUI_IMAGE_RESOLUTION_320x240; } else { std::cout << "Invalid Image Resolution" << std::endl; return RTC::RTC_ERROR; } if(m_enable_depth) { if(m_player_index) { hr = NuiImageStreamOpen(::NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX, eResolution, 0, 2, NULL, &m_pDepthStreamHandle ); } else { hr = NuiImageStreamOpen(::NUI_IMAGE_TYPE_DEPTH, eResolution, 0, 2, NULL, &m_pDepthStreamHandle ); } } if( FAILED( hr ) ) { std::cout << "NUI Image Stream Open Failed." << std::endl; return RTC::RTC_ERROR; } this->m_image.width = m_camera_width; this->m_image.height = m_camera_height; this->m_image.pixels.length(m_camera_width*m_camera_height*3); this->m_depth.width = m_depth_width; this->m_depth.height = m_depth_height; this->m_depth.pixels.length(m_depth_width*m_depth_height*3); /** * Initialization for raw sound input. */ if (m_enable_microphone) { UINT deviceCount; IMMDeviceEnumerator *deviceEnumerator = NULL; IMMDeviceCollection *deviceCollection = NULL; hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&deviceEnumerator)); if (FAILED(hr)) { std::cout << "Unable to instantiate device enumerator." << std::endl; return RTC::RTC_ERROR; } hr = deviceEnumerator->EnumAudioEndpoints(eCapture, DEVICE_STATE_ACTIVE, &deviceCollection); if (FAILED(hr)) { std::cout << "Unable to retrieve device collection." << std::endl; return RTC::RTC_ERROR; } hr = deviceCollection->GetCount(&deviceCount); if (FAILED(hr)) { std::cout << "Unable to get device collection length." << std::endl; return RTC::RTC_ERROR; } for (UINT i = 0; i < deviceCount; i++) { IPropertyStore *propertyStore; PROPVARIANT friendlyName; IMMDevice *endpoint; PropVariantInit(&friendlyName); hr = deviceCollection->Item(i, &endpoint); if (FAILED(hr)) { std::cout << "Unable to get device collection item." << std::endl; return RTC::RTC_ERROR; } hr = endpoint->OpenPropertyStore(STGM_READ, &propertyStore); if (FAILED(hr)) { std::cout << "Unable to open device property store." << std::endl; return RTC::RTC_ERROR; } hr = propertyStore->GetValue(PKEY_Device_FriendlyName, &friendlyName); SafeRelease(&propertyStore); if (FAILED(hr)) { std::cout << "Unable to retrieve friendly name for device." << std::endl; return RTC::RTC_ERROR; } std::cout << "Scanning for Kinect Audio device..." << std::endl; if (friendlyName.vt == VT_LPWSTR) { wprintf(L" %s\n", friendlyName.pwszVal); if (wcscmp(friendlyName.pwszVal, L"Kinect USB Audio") != 0) { std::cout << " Found Kinect Audio device" << std::endl; m_pAudioEndpoint = endpoint; m_pAudioEndpoint->AddRef(); PropVariantClear(&friendlyName); SafeRelease(&endpoint); break; } } PropVariantClear(&friendlyName); SafeRelease(&endpoint); } SafeRelease(&deviceCollection); SafeRelease(&deviceEnumerator); m_AudioShutdownEvent = CreateEvent(NULL, FALSE, FALSE, NULL); if (m_AudioShutdownEvent == NULL) { std::cout << "Unable to create shutdown event." << std::endl; return RTC::RTC_ERROR; } hr = m_pAudioEndpoint->Activate(__uuidof(IAudioClient), CLSCTX_INPROC_SERVER, NULL, reinterpret_cast<void **>(&m_pAudioClient)); if (FAILED(hr)) { std::cout << "Unable to activate audio client." << std::endl; return RTC::RTC_ERROR; } hr = m_pAudioClient->GetMixFormat(&m_pAudioMixFormat); if (FAILED(hr)) { std::cout << "Unable to get mix format on audio client." << std::endl; return RTC::RTC_ERROR; } m_AudioFrameSize = (m_pAudioMixFormat->wBitsPerSample / 8) * m_pAudioMixFormat->nChannels; m_AudioCaptureBufferSize = m_pAudioMixFormat->nSamplesPerSec * 5 * m_AudioFrameSize; m_pAudioCaptureBuffer = new (std::nothrow) BYTE[m_AudioCaptureBufferSize]; if (m_pAudioCaptureBuffer == NULL) { std::cout << "Unable to allocate capture buffer." << std::endl; return RTC::RTC_ERROR; } m_AudioCurrentCaptureIndex = 0; std::cout << "Audio capture format (" << m_pAudioMixFormat->nChannels << " channels, " << m_pAudioMixFormat->wBitsPerSample << " bits)"<< std::endl; m_AudioLatency = 10; hr = m_pAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_NOPERSIST, m_AudioLatency*10000, 0, m_pAudioMixFormat, NULL); if (FAILED(hr)) { std::cout << "Unable to initialize audio client." << std::endl; return RTC::RTC_ERROR; } hr = m_pAudioClient->GetService(IID_PPV_ARGS(&m_pAudioCaptureClient)); if (FAILED(hr)) { std::cout << "Unable to get audio capture client." << std::endl; return RTC::RTC_ERROR; } m_AudioCaptureThread = CreateThread(NULL, 0, AudioCaptureThread, this, 0, NULL); if (m_AudioCaptureThread == NULL) { std::cout << "Unable to create transport thread: " << GetLastError() << std::endl; return RTC::RTC_ERROR; } hr = m_pAudioClient->Start(); if (FAILED(hr)) { std::cout << "Unable to start audio capture client." << std::endl; return RTC::RTC_ERROR; } } return RTC::RTC_OK; }
bool CAESinkWASAPI::Initialize(AEAudioFormat &format, std::string &device) { if (m_initialized) return false; CLog::Log(LOGDEBUG, __FUNCTION__": Initializing WASAPI Sink Rev. 1.0.5"); m_device = device; /* Save requested format */ /* Clear returned format */ sinkReqFormat = format.m_dataFormat; sinkRetFormat = AE_FMT_INVALID; IMMDeviceEnumerator* pEnumerator = NULL; IMMDeviceCollection* pEnumDevices = NULL; HRESULT hr = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void**)&pEnumerator); EXIT_ON_FAILURE(hr, __FUNCTION__": Could not allocate WASAPI device enumerator. CoCreateInstance error code: %li", hr) //Get our device. //First try to find the named device. UINT uiCount = 0; hr = pEnumerator->EnumAudioEndpoints(eRender, DEVICE_STATE_ACTIVE, &pEnumDevices); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of audio endpoint enumeration failed.") hr = pEnumDevices->GetCount(&uiCount); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of audio endpoint count failed.") for (UINT i = 0; i < uiCount; i++) { IPropertyStore *pProperty = NULL; PROPVARIANT varName; hr = pEnumDevices->Item(i, &m_pDevice); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of WASAPI endpoint failed.") hr = m_pDevice->OpenPropertyStore(STGM_READ, &pProperty); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of WASAPI endpoint properties failed.") hr = pProperty->GetValue(PKEY_AudioEndpoint_GUID, &varName); if (FAILED(hr)) { CLog::Log(LOGERROR, __FUNCTION__": Retrieval of WASAPI endpoint GUID failed."); SAFE_RELEASE(pProperty); goto failed; } std::wstring strRawDevName(varName.pwszVal); std::string strDevName = std::string(strRawDevName.begin(), strRawDevName.end()); //g_charsetConverter.ucs2CharsetToStringCharset(strRawDevName, strDevName.c_str()); if (device == strDevName) i = uiCount; else SAFE_RELEASE(m_pDevice); PropVariantClear(&varName); SAFE_RELEASE(pProperty); } SAFE_RELEASE(pEnumDevices); if (!m_pDevice) { CLog::Log(LOGINFO, __FUNCTION__": Could not locate the device named \"%s\" in the list of WASAPI endpoint devices. Trying the default device...", device.c_str()); hr = pEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &m_pDevice); EXIT_ON_FAILURE(hr, __FUNCTION__": Could not retrieve the default WASAPI audio endpoint.") IPropertyStore *pProperty = NULL; PROPVARIANT varName; hr = m_pDevice->OpenPropertyStore(STGM_READ, &pProperty); EXIT_ON_FAILURE(hr, __FUNCTION__": Retrieval of WASAPI endpoint properties failed.") hr = pProperty->GetValue(PKEY_AudioEndpoint_GUID, &varName); std::wstring strRawDevName(varName.pwszVal); std::string strDevName = std::string(strRawDevName.begin(), strRawDevName.end()); PropVariantClear(&varName); SAFE_RELEASE(pProperty); } //We are done with the enumerator. SAFE_RELEASE(pEnumerator); hr = m_pDevice->Activate(IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&m_pAudioClient); EXIT_ON_FAILURE(hr, __FUNCTION__": Activating the WASAPI endpoint device failed.") if (!InitializeExclusive(format)) { CLog::Log(LOGINFO, __FUNCTION__": Could not Initialize Exclusive with that format"); goto failed; } /* get the buffer size and calculate the frames for AE */ m_pAudioClient->GetBufferSize(&m_uiBufferLen); format.m_frames = m_uiBufferLen; format.m_frameSamples = format.m_frames * format.m_channelLayout.Count(); m_format = format; sinkRetFormat = format.m_dataFormat; CLog::Log(LOGDEBUG, __FUNCTION__": Buffer Size = %d Bytes", m_uiBufferLen * format.m_frameSize); hr = m_pAudioClient->GetService(IID_IAudioRenderClient, (void**)&m_pRenderClient); EXIT_ON_FAILURE(hr, __FUNCTION__": Could not initialize the WASAPI render client interface.") m_needDataEvent = CreateEvent(NULL, FALSE, FALSE, NULL); hr = m_pAudioClient->SetEventHandle(m_needDataEvent); EXIT_ON_FAILURE(hr, __FUNCTION__": Could not set the WASAPI event handler."); m_initialized = true; m_isDirty = false; return true; failed: CLog::Log(LOGERROR, __FUNCTION__": WASAPI initialization failed."); SAFE_RELEASE(pEnumDevices); SAFE_RELEASE(pEnumerator); SAFE_RELEASE(m_pRenderClient); SAFE_RELEASE(m_pAudioClient); SAFE_RELEASE(m_pDevice); CloseHandle(m_needDataEvent); return false; }