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 "media/audio/audio_io.h" 6 7 #include <windows.h> 8 #include <objbase.h> // This has to be before initguid.h 9 #include <initguid.h> 10 #include <mmsystem.h> 11 #include <setupapi.h> 12 13 #include "base/bind.h" 14 #include "base/bind_helpers.h" 15 #include "base/command_line.h" 16 #include "base/files/file_path.h" 17 #include "base/memory/scoped_ptr.h" 18 #include "base/message_loop/message_loop.h" 19 #include "base/path_service.h" 20 #include "base/process/launch.h" 21 #include "base/strings/string_number_conversions.h" 22 #include "base/strings/string_util.h" 23 #include "base/win/windows_version.h" 24 #include "media/audio/audio_parameters.h" 25 #include "media/audio/win/audio_device_listener_win.h" 26 #include "media/audio/win/audio_low_latency_input_win.h" 27 #include "media/audio/win/audio_low_latency_output_win.h" 28 #include "media/audio/win/audio_manager_win.h" 29 #include "media/audio/win/core_audio_util_win.h" 30 #include "media/audio/win/device_enumeration_win.h" 31 #include "media/audio/win/wavein_input_win.h" 32 #include "media/audio/win/waveout_output_win.h" 33 #include "media/base/bind_to_current_loop.h" 34 #include "media/base/channel_layout.h" 35 #include "media/base/limits.h" 36 #include "media/base/media_switches.h" 37 38 // Libraries required for the SetupAPI and Wbem APIs used here. 39 #pragma comment(lib, "setupapi.lib") 40 41 // The following are defined in various DDK headers, and we (re)define them here 42 // to avoid adding the DDK as a chrome dependency. 43 #define DRV_QUERYDEVICEINTERFACE 0x80c 44 #define DRVM_MAPPER_PREFERRED_GET 0x2015 45 #define DRV_QUERYDEVICEINTERFACESIZE 0x80d 46 DEFINE_GUID(AM_KSCATEGORY_AUDIO, 0x6994ad04, 0x93ef, 0x11d0, 47 0xa3, 0xcc, 0x00, 0xa0, 0xc9, 0x22, 0x31, 0x96); 48 49 namespace media { 50 51 // Maximum number of output streams that can be open simultaneously. 52 static const int kMaxOutputStreams = 50; 53 54 // Up to 8 channels can be passed to the driver. This should work, given the 55 // right drivers, but graceful error handling is needed. 56 static const int kWinMaxChannels = 8; 57 58 // We use 3 buffers for recording audio so that if a recording callback takes 59 // some time to return we won't lose audio. More buffers while recording are 60 // ok because they don't introduce any delay in recording, unlike in playback 61 // where you first need to fill in that number of buffers before starting to 62 // play. 63 static const int kNumInputBuffers = 3; 64 65 // Buffer size to use for input and output stream when a proper size can't be 66 // determined from the system 67 static const int kFallbackBufferSize = 2048; 68 69 static int GetVersionPartAsInt(DWORDLONG num) { 70 return static_cast<int>(num & 0xffff); 71 } 72 73 // Returns a string containing the given device's description and installed 74 // driver version. 75 static base::string16 GetDeviceAndDriverInfo(HDEVINFO device_info, 76 SP_DEVINFO_DATA* device_data) { 77 // Save the old install params setting and set a flag for the 78 // SetupDiBuildDriverInfoList below to return only the installed drivers. 79 SP_DEVINSTALL_PARAMS old_device_install_params; 80 old_device_install_params.cbSize = sizeof(old_device_install_params); 81 SetupDiGetDeviceInstallParams(device_info, device_data, 82 &old_device_install_params); 83 SP_DEVINSTALL_PARAMS device_install_params = old_device_install_params; 84 device_install_params.FlagsEx |= DI_FLAGSEX_INSTALLEDDRIVER; 85 SetupDiSetDeviceInstallParams(device_info, device_data, 86 &device_install_params); 87 88 SP_DRVINFO_DATA driver_data; 89 driver_data.cbSize = sizeof(driver_data); 90 base::string16 device_and_driver_info; 91 if (SetupDiBuildDriverInfoList(device_info, device_data, 92 SPDIT_COMPATDRIVER)) { 93 if (SetupDiEnumDriverInfo(device_info, device_data, SPDIT_COMPATDRIVER, 0, 94 &driver_data)) { 95 DWORDLONG version = driver_data.DriverVersion; 96 device_and_driver_info = base::string16(driver_data.Description) + L" v" + 97 base::IntToString16(GetVersionPartAsInt((version >> 48))) + L"." + 98 base::IntToString16(GetVersionPartAsInt((version >> 32))) + L"." + 99 base::IntToString16(GetVersionPartAsInt((version >> 16))) + L"." + 100 base::IntToString16(GetVersionPartAsInt(version)); 101 } 102 SetupDiDestroyDriverInfoList(device_info, device_data, SPDIT_COMPATDRIVER); 103 } 104 105 SetupDiSetDeviceInstallParams(device_info, device_data, 106 &old_device_install_params); 107 108 return device_and_driver_info; 109 } 110 111 static int NumberOfWaveOutBuffers() { 112 // Use the user provided buffer count if provided. 113 int buffers = 0; 114 std::string buffers_str(CommandLine::ForCurrentProcess()->GetSwitchValueASCII( 115 switches::kWaveOutBuffers)); 116 if (base::StringToInt(buffers_str, &buffers) && buffers > 0) { 117 return buffers; 118 } 119 120 // Use 4 buffers for Vista, 3 for everyone else: 121 // - The entire Windows audio stack was rewritten for Windows Vista and wave 122 // out performance was degraded compared to XP. 123 // - The regression was fixed in Windows 7 and most configurations will work 124 // with 2, but some (e.g., some Sound Blasters) still need 3. 125 // - Some XP configurations (even multi-processor ones) also need 3. 126 return (base::win::GetVersion() == base::win::VERSION_VISTA) ? 4 : 3; 127 } 128 129 AudioManagerWin::AudioManagerWin(AudioLogFactory* audio_log_factory) 130 : AudioManagerBase(audio_log_factory), 131 // |CoreAudioUtil::IsSupported()| uses static variables to avoid doing 132 // multiple initializations. This is however not thread safe. 133 // So, here we call it explicitly before we kick off the audio thread 134 // or do any other work. 135 enumeration_type_(CoreAudioUtil::IsSupported() ? 136 kMMDeviceEnumeration : kWaveEnumeration) { 137 SetMaxOutputStreamsAllowed(kMaxOutputStreams); 138 139 // WARNING: This is executed on the UI loop, do not add any code here which 140 // loads libraries or attempts to call out into the OS. Instead add such code 141 // to the InitializeOnAudioThread() method below. 142 143 // Task must be posted last to avoid races from handing out "this" to the 144 // audio thread. 145 GetTaskRunner()->PostTask(FROM_HERE, base::Bind( 146 &AudioManagerWin::InitializeOnAudioThread, base::Unretained(this))); 147 } 148 149 AudioManagerWin::~AudioManagerWin() { 150 // It's safe to post a task here since Shutdown() will wait for all tasks to 151 // complete before returning. 152 GetTaskRunner()->PostTask(FROM_HERE, base::Bind( 153 &AudioManagerWin::ShutdownOnAudioThread, base::Unretained(this))); 154 Shutdown(); 155 } 156 157 bool AudioManagerWin::HasAudioOutputDevices() { 158 return (::waveOutGetNumDevs() != 0); 159 } 160 161 bool AudioManagerWin::HasAudioInputDevices() { 162 return (::waveInGetNumDevs() != 0); 163 } 164 165 void AudioManagerWin::InitializeOnAudioThread() { 166 DCHECK(GetTaskRunner()->BelongsToCurrentThread()); 167 168 if (core_audio_supported()) { 169 // AudioDeviceListenerWin must be initialized on a COM thread and should 170 // only be used if WASAPI / Core Audio is supported. 171 output_device_listener_.reset(new AudioDeviceListenerWin(BindToCurrentLoop( 172 base::Bind(&AudioManagerWin::NotifyAllOutputDeviceChangeListeners, 173 base::Unretained(this))))); 174 } 175 } 176 177 void AudioManagerWin::ShutdownOnAudioThread() { 178 DCHECK(GetTaskRunner()->BelongsToCurrentThread()); 179 output_device_listener_.reset(); 180 } 181 182 base::string16 AudioManagerWin::GetAudioInputDeviceModel() { 183 // Get the default audio capture device and its device interface name. 184 DWORD device_id = 0; 185 waveInMessage(reinterpret_cast<HWAVEIN>(WAVE_MAPPER), 186 DRVM_MAPPER_PREFERRED_GET, 187 reinterpret_cast<DWORD_PTR>(&device_id), NULL); 188 ULONG device_interface_name_size = 0; 189 waveInMessage(reinterpret_cast<HWAVEIN>(device_id), 190 DRV_QUERYDEVICEINTERFACESIZE, 191 reinterpret_cast<DWORD_PTR>(&device_interface_name_size), 0); 192 size_t bytes_in_char16 = sizeof(base::string16::value_type); 193 DCHECK_EQ(0u, device_interface_name_size % bytes_in_char16); 194 if (device_interface_name_size <= bytes_in_char16) 195 return base::string16(); // No audio capture device. 196 197 base::string16 device_interface_name; 198 base::string16::value_type* name_ptr = WriteInto(&device_interface_name, 199 device_interface_name_size / bytes_in_char16); 200 waveInMessage(reinterpret_cast<HWAVEIN>(device_id), 201 DRV_QUERYDEVICEINTERFACE, 202 reinterpret_cast<DWORD_PTR>(name_ptr), 203 static_cast<DWORD_PTR>(device_interface_name_size)); 204 205 // Enumerate all audio devices and find the one matching the above device 206 // interface name. 207 HDEVINFO device_info = SetupDiGetClassDevs( 208 &AM_KSCATEGORY_AUDIO, 0, 0, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT); 209 if (device_info == INVALID_HANDLE_VALUE) 210 return base::string16(); 211 212 DWORD interface_index = 0; 213 SP_DEVICE_INTERFACE_DATA interface_data; 214 interface_data.cbSize = sizeof(interface_data); 215 while (SetupDiEnumDeviceInterfaces(device_info, 0, &AM_KSCATEGORY_AUDIO, 216 interface_index++, &interface_data)) { 217 // Query the size of the struct, allocate it and then query the data. 218 SP_DEVINFO_DATA device_data; 219 device_data.cbSize = sizeof(device_data); 220 DWORD interface_detail_size = 0; 221 SetupDiGetDeviceInterfaceDetail(device_info, &interface_data, 0, 0, 222 &interface_detail_size, &device_data); 223 if (!interface_detail_size) 224 continue; 225 226 scoped_ptr<char[]> interface_detail_buffer(new char[interface_detail_size]); 227 SP_DEVICE_INTERFACE_DETAIL_DATA* interface_detail = 228 reinterpret_cast<SP_DEVICE_INTERFACE_DETAIL_DATA*>( 229 interface_detail_buffer.get()); 230 interface_detail->cbSize = interface_detail_size; 231 if (!SetupDiGetDeviceInterfaceDetail(device_info, &interface_data, 232 interface_detail, 233 interface_detail_size, NULL, 234 &device_data)) 235 return base::string16(); 236 237 bool device_found = (device_interface_name == interface_detail->DevicePath); 238 239 if (device_found) 240 return GetDeviceAndDriverInfo(device_info, &device_data); 241 } 242 243 return base::string16(); 244 } 245 246 void AudioManagerWin::ShowAudioInputSettings() { 247 std::wstring program; 248 std::string argument; 249 if (!core_audio_supported()) { 250 program = L"sndvol32.exe"; 251 argument = "-R"; 252 } else { 253 program = L"control.exe"; 254 argument = "mmsys.cpl,,1"; 255 } 256 257 base::FilePath path; 258 PathService::Get(base::DIR_SYSTEM, &path); 259 path = path.Append(program); 260 CommandLine command_line(path); 261 command_line.AppendArg(argument); 262 base::LaunchProcess(command_line, base::LaunchOptions(), NULL); 263 } 264 265 void AudioManagerWin::GetAudioDeviceNamesImpl( 266 bool input, 267 AudioDeviceNames* device_names) { 268 DCHECK(device_names->empty()); 269 // Enumerate all active audio-endpoint capture devices. 270 if (enumeration_type() == kWaveEnumeration) { 271 // Utilize the Wave API for Windows XP. 272 if (input) 273 GetInputDeviceNamesWinXP(device_names); 274 else 275 GetOutputDeviceNamesWinXP(device_names); 276 } else { 277 // Utilize the MMDevice API (part of Core Audio) for Vista and higher. 278 if (input) 279 GetInputDeviceNamesWin(device_names); 280 else 281 GetOutputDeviceNamesWin(device_names); 282 } 283 284 // Always add default device parameters as first element. 285 if (!device_names->empty()) { 286 AudioDeviceName name; 287 name.device_name = AudioManagerBase::kDefaultDeviceName; 288 name.unique_id = AudioManagerBase::kDefaultDeviceId; 289 device_names->push_front(name); 290 } 291 } 292 293 void AudioManagerWin::GetAudioInputDeviceNames(AudioDeviceNames* device_names) { 294 GetAudioDeviceNamesImpl(true, device_names); 295 } 296 297 void AudioManagerWin::GetAudioOutputDeviceNames( 298 AudioDeviceNames* device_names) { 299 GetAudioDeviceNamesImpl(false, device_names); 300 } 301 302 AudioParameters AudioManagerWin::GetInputStreamParameters( 303 const std::string& device_id) { 304 AudioParameters parameters; 305 if (!core_audio_supported()) { 306 // Windows Wave implementation is being used. 307 parameters = AudioParameters( 308 AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO, 0, 48000, 309 16, kFallbackBufferSize, AudioParameters::NO_EFFECTS); 310 } else { 311 parameters = WASAPIAudioInputStream::GetInputStreamParameters(device_id); 312 } 313 314 int user_buffer_size = GetUserBufferSize(); 315 if (user_buffer_size) { 316 parameters.Reset(parameters.format(), parameters.channel_layout(), 317 parameters.channels(), parameters.input_channels(), 318 parameters.sample_rate(), parameters.bits_per_sample(), 319 user_buffer_size); 320 } 321 322 return parameters; 323 } 324 325 std::string AudioManagerWin::GetAssociatedOutputDeviceID( 326 const std::string& input_device_id) { 327 if (!core_audio_supported()) { 328 NOTIMPLEMENTED() 329 << "GetAssociatedOutputDeviceID is not supported on this OS"; 330 return std::string(); 331 } 332 return CoreAudioUtil::GetMatchingOutputDeviceID(input_device_id); 333 } 334 335 // Factory for the implementations of AudioOutputStream for AUDIO_PCM_LINEAR 336 // mode. 337 // - PCMWaveOutAudioOutputStream: Based on the waveOut API. 338 AudioOutputStream* AudioManagerWin::MakeLinearOutputStream( 339 const AudioParameters& params) { 340 DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format()); 341 if (params.channels() > kWinMaxChannels) 342 return NULL; 343 344 return new PCMWaveOutAudioOutputStream(this, 345 params, 346 NumberOfWaveOutBuffers(), 347 WAVE_MAPPER); 348 } 349 350 // Factory for the implementations of AudioOutputStream for 351 // AUDIO_PCM_LOW_LATENCY mode. Two implementations should suffice most 352 // windows user's needs. 353 // - PCMWaveOutAudioOutputStream: Based on the waveOut API. 354 // - WASAPIAudioOutputStream: Based on Core Audio (WASAPI) API. 355 AudioOutputStream* AudioManagerWin::MakeLowLatencyOutputStream( 356 const AudioParameters& params, 357 const std::string& device_id) { 358 DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format()); 359 if (params.channels() > kWinMaxChannels) 360 return NULL; 361 362 if (!core_audio_supported()) { 363 // Fall back to Windows Wave implementation on Windows XP or lower. 364 DLOG_IF(ERROR, !device_id.empty() && 365 device_id != AudioManagerBase::kDefaultDeviceId) 366 << "Opening by device id not supported by PCMWaveOutAudioOutputStream"; 367 DVLOG(1) << "Using WaveOut since WASAPI requires at least Vista."; 368 return new PCMWaveOutAudioOutputStream( 369 this, params, NumberOfWaveOutBuffers(), WAVE_MAPPER); 370 } 371 372 // Pass an empty string to indicate that we want the default device 373 // since we consistently only check for an empty string in 374 // WASAPIAudioOutputStream. 375 return new WASAPIAudioOutputStream(this, 376 device_id == AudioManagerBase::kDefaultDeviceId ? 377 std::string() : device_id, 378 params, 379 params.effects() & AudioParameters::DUCKING ? eCommunications : eConsole); 380 } 381 382 // Factory for the implementations of AudioInputStream for AUDIO_PCM_LINEAR 383 // mode. 384 AudioInputStream* AudioManagerWin::MakeLinearInputStream( 385 const AudioParameters& params, const std::string& device_id) { 386 DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format()); 387 return CreatePCMWaveInAudioInputStream(params, device_id); 388 } 389 390 // Factory for the implementations of AudioInputStream for 391 // AUDIO_PCM_LOW_LATENCY mode. 392 AudioInputStream* AudioManagerWin::MakeLowLatencyInputStream( 393 const AudioParameters& params, const std::string& device_id) { 394 DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format()); 395 DVLOG(1) << "MakeLowLatencyInputStream: " << device_id; 396 AudioInputStream* stream = NULL; 397 if (!core_audio_supported()) { 398 // Fall back to Windows Wave implementation on Windows XP or lower. 399 DVLOG(1) << "Using WaveIn since WASAPI requires at least Vista."; 400 stream = CreatePCMWaveInAudioInputStream(params, device_id); 401 } else { 402 stream = new WASAPIAudioInputStream(this, params, device_id); 403 } 404 405 return stream; 406 } 407 408 std::string AudioManagerWin::GetDefaultOutputDeviceID() { 409 if (!core_audio_supported()) 410 return std::string(); 411 return CoreAudioUtil::GetDefaultOutputDeviceID(); 412 } 413 414 AudioParameters AudioManagerWin::GetPreferredOutputStreamParameters( 415 const std::string& output_device_id, 416 const AudioParameters& input_params) { 417 DLOG_IF(ERROR, !core_audio_supported() && !output_device_id.empty()) 418 << "CoreAudio is required to open non-default devices."; 419 420 const CommandLine* cmd_line = CommandLine::ForCurrentProcess(); 421 ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO; 422 int sample_rate = 48000; 423 int buffer_size = kFallbackBufferSize; 424 int bits_per_sample = 16; 425 int input_channels = 0; 426 int effects = AudioParameters::NO_EFFECTS; 427 bool use_input_params = !core_audio_supported(); 428 if (core_audio_supported()) { 429 if (cmd_line->HasSwitch(switches::kEnableExclusiveAudio)) { 430 // TODO(rtoy): tune these values for best possible WebAudio 431 // performance. WebRTC works well at 48kHz and a buffer size of 480 432 // samples will be used for this case. Note that exclusive mode is 433 // experimental. This sample rate will be combined with a buffer size of 434 // 256 samples, which corresponds to an output delay of ~5.33ms. 435 sample_rate = 48000; 436 buffer_size = 256; 437 if (input_params.IsValid()) 438 channel_layout = input_params.channel_layout(); 439 } else { 440 AudioParameters params; 441 HRESULT hr = CoreAudioUtil::GetPreferredAudioParameters( 442 output_device_id.empty() ? 443 GetDefaultOutputDeviceID() : output_device_id, 444 ¶ms); 445 if (SUCCEEDED(hr)) { 446 bits_per_sample = params.bits_per_sample(); 447 buffer_size = params.frames_per_buffer(); 448 channel_layout = params.channel_layout(); 449 sample_rate = params.sample_rate(); 450 effects = params.effects(); 451 } else { 452 // TODO(tommi): This should never happen really and I'm not sure that 453 // setting use_input_params is the right thing to do since WASAPI i 454 // definitely supported (see core_audio_supported() above) and 455 // |use_input_params| is only for cases when it isn't supported. 456 DLOG(ERROR) << "GetPreferredAudioParameters failed: " << std::hex << hr; 457 use_input_params = true; 458 } 459 } 460 } 461 462 if (input_params.IsValid()) { 463 // If the user has enabled checking supported channel layouts or we don't 464 // have a valid channel layout yet, try to use the input layout. See bugs 465 // http://crbug.com/259165 and http://crbug.com/311906 for more details. 466 if (core_audio_supported() && 467 (cmd_line->HasSwitch(switches::kTrySupportedChannelLayouts) || 468 channel_layout == CHANNEL_LAYOUT_UNSUPPORTED)) { 469 // Check if it is possible to open up at the specified input channel 470 // layout but avoid checking if the specified layout is the same as the 471 // hardware (preferred) layout. We do this extra check to avoid the 472 // CoreAudioUtil::IsChannelLayoutSupported() overhead in most cases. 473 if (input_params.channel_layout() != channel_layout) { 474 // TODO(henrika): Internally, IsChannelLayoutSupported does many of the 475 // operations that have already been done such as opening up a client 476 // and fetching the WAVEFORMATPCMEX format. Ideally we should only do 477 // that once. Then here, we can check the layout from the data we 478 // already hold. 479 if (CoreAudioUtil::IsChannelLayoutSupported( 480 output_device_id, eRender, eConsole, 481 input_params.channel_layout())) { 482 // Open up using the same channel layout as the source if it is 483 // supported by the hardware. 484 channel_layout = input_params.channel_layout(); 485 VLOG(1) << "Hardware channel layout is not used; using same layout" 486 << " as the source instead (" << channel_layout << ")"; 487 } 488 } 489 } 490 input_channels = input_params.input_channels(); 491 effects |= input_params.effects(); 492 if (use_input_params) { 493 // If WASAPI isn't supported we'll fallback to WaveOut, which will take 494 // care of resampling and bits per sample changes. By setting these 495 // equal to the input values, AudioOutputResampler will skip resampling 496 // and bit per sample differences (since the input parameters will match 497 // the output parameters). 498 bits_per_sample = input_params.bits_per_sample(); 499 buffer_size = input_params.frames_per_buffer(); 500 channel_layout = input_params.channel_layout(); 501 sample_rate = input_params.sample_rate(); 502 } 503 } 504 505 int user_buffer_size = GetUserBufferSize(); 506 if (user_buffer_size) 507 buffer_size = user_buffer_size; 508 509 return AudioParameters( 510 AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout, input_channels, 511 sample_rate, bits_per_sample, buffer_size, effects); 512 } 513 514 AudioInputStream* AudioManagerWin::CreatePCMWaveInAudioInputStream( 515 const AudioParameters& params, 516 const std::string& device_id) { 517 std::string xp_device_id = device_id; 518 if (device_id != AudioManagerBase::kDefaultDeviceId && 519 enumeration_type_ == kMMDeviceEnumeration) { 520 xp_device_id = ConvertToWinXPInputDeviceId(device_id); 521 if (xp_device_id.empty()) { 522 DLOG(ERROR) << "Cannot find a waveIn device which matches the device ID " 523 << device_id; 524 return NULL; 525 } 526 } 527 528 return new PCMWaveInAudioInputStream(this, params, kNumInputBuffers, 529 xp_device_id); 530 } 531 532 /// static 533 AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory) { 534 return new AudioManagerWin(audio_log_factory); 535 } 536 537 } // namespace media 538
