1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include <MMDeviceAPI.h> 6#include <mmsystem.h> 7#include <Functiondiscoverykeys_devpkey.h> // MMDeviceAPI.h must come first 8 9#include "media/audio/win/audio_manager_win.h" 10 11#include "base/basictypes.h" 12#include "base/logging.h" 13#include "base/strings/utf_string_conversions.h" 14#include "base/win/scoped_co_mem.h" 15#include "base/win/scoped_comptr.h" 16#include "base/win/scoped_propvariant.h" 17 18using base::win::ScopedComPtr; 19using base::win::ScopedCoMem; 20 21// Taken from Mmddk.h. 22#define DRV_RESERVED 0x0800 23#define DRV_QUERYFUNCTIONINSTANCEID (DRV_RESERVED + 17) 24#define DRV_QUERYFUNCTIONINSTANCEIDSIZE (DRV_RESERVED + 18) 25 26namespace media { 27 28static bool GetDeviceNamesWinImpl(EDataFlow data_flow, 29 AudioDeviceNames* device_names) { 30 // It is assumed that this method is called from a COM thread, i.e., 31 // CoInitializeEx() is not called here again to avoid STA/MTA conflicts. 32 ScopedComPtr<IMMDeviceEnumerator> enumerator; 33 HRESULT hr = enumerator.CreateInstance(__uuidof(MMDeviceEnumerator), NULL, 34 CLSCTX_INPROC_SERVER); 35 DCHECK_NE(CO_E_NOTINITIALIZED, hr); 36 if (FAILED(hr)) { 37 LOG(WARNING) << "Failed to create IMMDeviceEnumerator: " << std::hex << hr; 38 return false; 39 } 40 41 // Generate a collection of active audio endpoint devices. 42 // This method will succeed even if all devices are disabled. 43 ScopedComPtr<IMMDeviceCollection> collection; 44 hr = enumerator->EnumAudioEndpoints(data_flow, 45 DEVICE_STATE_ACTIVE, 46 collection.Receive()); 47 if (FAILED(hr)) 48 return false; 49 50 // Retrieve the number of active devices. 51 UINT number_of_active_devices = 0; 52 collection->GetCount(&number_of_active_devices); 53 if (number_of_active_devices == 0) 54 return true; 55 56 AudioDeviceName device; 57 58 // Loop over all active devices and add friendly name and 59 // unique ID to the |device_names| list. 60 for (UINT i = 0; i < number_of_active_devices; ++i) { 61 // Retrieve unique name of endpoint device. 62 // Example: "{0.0.1.00000000}.{8db6020f-18e3-4f25-b6f5-7726c9122574}". 63 ScopedComPtr<IMMDevice> audio_device; 64 hr = collection->Item(i, audio_device.Receive()); 65 if (FAILED(hr)) 66 continue; 67 68 // Store the unique name. 69 ScopedCoMem<WCHAR> endpoint_device_id; 70 audio_device->GetId(&endpoint_device_id); 71 device.unique_id = 72 base::WideToUTF8(static_cast<WCHAR*>(endpoint_device_id)); 73 74 // Retrieve user-friendly name of endpoint device. 75 // Example: "Microphone (Realtek High Definition Audio)". 76 ScopedComPtr<IPropertyStore> properties; 77 hr = audio_device->OpenPropertyStore(STGM_READ, properties.Receive()); 78 if (SUCCEEDED(hr)) { 79 base::win::ScopedPropVariant friendly_name; 80 hr = properties->GetValue(PKEY_Device_FriendlyName, 81 friendly_name.Receive()); 82 83 // Store the user-friendly name. 84 if (SUCCEEDED(hr) && 85 friendly_name.get().vt == VT_LPWSTR && friendly_name.get().pwszVal) { 86 device.device_name = base::WideToUTF8(friendly_name.get().pwszVal); 87 } 88 } 89 90 // Add combination of user-friendly and unique name to the output list. 91 device_names->push_back(device); 92 } 93 94 return true; 95} 96 97// The waveform API is weird in that it has completely separate but 98// almost identical functions and structs for input devices vs. output 99// devices. We deal with this by implementing the logic as a templated 100// function that takes the functions and struct type to use as 101// template parameters. 102template <UINT (__stdcall *NumDevsFunc)(), 103 typename CAPSSTRUCT, 104 MMRESULT (__stdcall *DevCapsFunc)(UINT_PTR, CAPSSTRUCT*, UINT)> 105static bool GetDeviceNamesWinXPImpl(AudioDeviceNames* device_names) { 106 // Retrieve the number of active waveform input devices. 107 UINT number_of_active_devices = NumDevsFunc(); 108 if (number_of_active_devices == 0) 109 return true; 110 111 AudioDeviceName device; 112 CAPSSTRUCT capabilities; 113 MMRESULT err = MMSYSERR_NOERROR; 114 115 // Loop over all active capture devices and add friendly name and 116 // unique ID to the |device_names| list. Note that, for Wave on XP, 117 // the "unique" name will simply be a copy of the friendly name since 118 // there is no safe method to retrieve a unique device name on XP. 119 for (UINT i = 0; i < number_of_active_devices; ++i) { 120 // Retrieve the capabilities of the specified waveform-audio input device. 121 err = DevCapsFunc(i, &capabilities, sizeof(capabilities)); 122 if (err != MMSYSERR_NOERROR) 123 continue; 124 125 // Store the user-friendly name. Max length is MAXPNAMELEN(=32) 126 // characters and the name cane be truncated on XP. 127 // Example: "Microphone (Realtek High Defini". 128 device.device_name = base::WideToUTF8(capabilities.szPname); 129 130 // Store the "unique" name (we use same as friendly name on Windows XP). 131 device.unique_id = device.device_name; 132 133 // Add combination of user-friendly and unique name to the output list. 134 device_names->push_back(device); 135 } 136 137 return true; 138} 139 140bool GetInputDeviceNamesWin(AudioDeviceNames* device_names) { 141 return GetDeviceNamesWinImpl(eCapture, device_names); 142} 143 144bool GetOutputDeviceNamesWin(AudioDeviceNames* device_names) { 145 return GetDeviceNamesWinImpl(eRender, device_names); 146} 147 148bool GetInputDeviceNamesWinXP(AudioDeviceNames* device_names) { 149 return GetDeviceNamesWinXPImpl< 150 waveInGetNumDevs, WAVEINCAPSW, waveInGetDevCapsW>(device_names); 151} 152 153bool GetOutputDeviceNamesWinXP(AudioDeviceNames* device_names) { 154 return GetDeviceNamesWinXPImpl< 155 waveOutGetNumDevs, WAVEOUTCAPSW, waveOutGetDevCapsW>(device_names); 156} 157 158std::string ConvertToWinXPInputDeviceId(const std::string& device_id) { 159 UINT number_of_active_devices = waveInGetNumDevs(); 160 MMRESULT result = MMSYSERR_NOERROR; 161 162 UINT i = 0; 163 for (; i < number_of_active_devices; ++i) { 164 size_t size = 0; 165 // Get the size (including the terminating NULL) of the endpoint ID of the 166 // waveIn device. 167 result = waveInMessage(reinterpret_cast<HWAVEIN>(i), 168 DRV_QUERYFUNCTIONINSTANCEIDSIZE, 169 reinterpret_cast<DWORD_PTR>(&size), NULL); 170 if (result != MMSYSERR_NOERROR) 171 continue; 172 173 ScopedCoMem<WCHAR> id; 174 id.Reset(static_cast<WCHAR*>(CoTaskMemAlloc(size))); 175 if (!id) 176 continue; 177 178 // Get the endpoint ID string for this waveIn device. 179 result = waveInMessage( 180 reinterpret_cast<HWAVEIN>(i), DRV_QUERYFUNCTIONINSTANCEID, 181 reinterpret_cast<DWORD_PTR>(static_cast<WCHAR*>(id)), size); 182 if (result != MMSYSERR_NOERROR) 183 continue; 184 185 std::string utf8_id = base::WideToUTF8(static_cast<WCHAR*>(id)); 186 // Check whether the endpoint ID string of this waveIn device matches that 187 // of the audio endpoint device. 188 if (device_id == utf8_id) 189 break; 190 } 191 192 // If a matching waveIn device was found, convert the unique endpoint ID 193 // string to a standard friendly name with max 32 characters. 194 if (i < number_of_active_devices) { 195 WAVEINCAPS capabilities; 196 197 result = waveInGetDevCaps(i, &capabilities, sizeof(capabilities)); 198 if (result == MMSYSERR_NOERROR) 199 return base::WideToUTF8(capabilities.szPname); 200 } 201 202 return std::string(); 203} 204 205} // namespace media 206