blob: 06f9ccb603e64f5b784318f21dffc09da500f9bb [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "media/audio/audio_io.h"
#include <windows.h>
#include <objbase.h> // This has to be before initguid.h
#include <initguid.h>
#include <mmsystem.h>
#include <setupapi.h>
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/memory/scoped_ptr.h"
#include "base/message_loop/message_loop.h"
#include "base/path_service.h"
#include "base/process/launch.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/win/windows_version.h"
#include "media/audio/audio_parameters.h"
#include "media/audio/win/audio_device_listener_win.h"
#include "media/audio/win/audio_low_latency_input_win.h"
#include "media/audio/win/audio_low_latency_output_win.h"
#include "media/audio/win/audio_manager_win.h"
#include "media/audio/win/audio_unified_win.h"
#include "media/audio/win/core_audio_util_win.h"
#include "media/audio/win/device_enumeration_win.h"
#include "media/audio/win/wavein_input_win.h"
#include "media/audio/win/waveout_output_win.h"
#include "media/base/bind_to_loop.h"
#include "media/base/channel_layout.h"
#include "media/base/limits.h"
#include "media/base/media_switches.h"
// Libraries required for the SetupAPI and Wbem APIs used here.
#pragma comment(lib, "setupapi.lib")
// The following are defined in various DDK headers, and we (re)define them here
// to avoid adding the DDK as a chrome dependency.
DEFINE_GUID(AM_KSCATEGORY_AUDIO, 0x6994ad04, 0x93ef, 0x11d0,
0xa3, 0xcc, 0x00, 0xa0, 0xc9, 0x22, 0x31, 0x96);
namespace media {
// Maximum number of output streams that can be open simultaneously.
static const int kMaxOutputStreams = 50;
// Up to 8 channels can be passed to the driver. This should work, given the
// right drivers, but graceful error handling is needed.
static const int kWinMaxChannels = 8;
// We use 3 buffers for recording audio so that if a recording callback takes
// some time to return we won't lose audio. More buffers while recording are
// ok because they don't introduce any delay in recording, unlike in playback
// where you first need to fill in that number of buffers before starting to
// play.
static const int kNumInputBuffers = 3;
// Buffer size to use for input and output stream when a proper size can't be
// determined from the system
static const int kFallbackBufferSize = 2048;
static int GetVersionPartAsInt(DWORDLONG num) {
return static_cast<int>(num & 0xffff);
// Returns a string containing the given device's description and installed
// driver version.
static string16 GetDeviceAndDriverInfo(HDEVINFO device_info,
SP_DEVINFO_DATA* device_data) {
// Save the old install params setting and set a flag for the
// SetupDiBuildDriverInfoList below to return only the installed drivers.
SP_DEVINSTALL_PARAMS old_device_install_params;
old_device_install_params.cbSize = sizeof(old_device_install_params);
SetupDiGetDeviceInstallParams(device_info, device_data,
SP_DEVINSTALL_PARAMS device_install_params = old_device_install_params;
device_install_params.FlagsEx |= DI_FLAGSEX_INSTALLEDDRIVER;
SetupDiSetDeviceInstallParams(device_info, device_data,
SP_DRVINFO_DATA driver_data;
driver_data.cbSize = sizeof(driver_data);
string16 device_and_driver_info;
if (SetupDiBuildDriverInfoList(device_info, device_data,
if (SetupDiEnumDriverInfo(device_info, device_data, SPDIT_COMPATDRIVER, 0,
&driver_data)) {
DWORDLONG version = driver_data.DriverVersion;
device_and_driver_info = string16(driver_data.Description) + L" v" +
base::IntToString16(GetVersionPartAsInt((version >> 48))) + L"." +
base::IntToString16(GetVersionPartAsInt((version >> 32))) + L"." +
base::IntToString16(GetVersionPartAsInt((version >> 16))) + L"." +
SetupDiDestroyDriverInfoList(device_info, device_data, SPDIT_COMPATDRIVER);
SetupDiSetDeviceInstallParams(device_info, device_data,
return device_and_driver_info;
static int NumberOfWaveOutBuffers() {
// Use the user provided buffer count if provided.
int buffers = 0;
std::string buffers_str(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
if (base::StringToInt(buffers_str, &buffers) && buffers > 0) {
return buffers;
// Use 4 buffers for Vista, 3 for everyone else:
// - The entire Windows audio stack was rewritten for Windows Vista and wave
// out performance was degraded compared to XP.
// - The regression was fixed in Windows 7 and most configurations will work
// with 2, but some (e.g., some Sound Blasters) still need 3.
// - Some XP configurations (even multi-processor ones) also need 3.
return (base::win::GetVersion() == base::win::VERSION_VISTA) ? 4 : 3;
AudioManagerWin::AudioManagerWin() {
if (!CoreAudioUtil::IsSupported()) {
// Use the Wave API for device enumeration if XP or lower.
enumeration_type_ = kWaveEnumeration;
} else {
// Use the MMDevice API for device enumeration if Vista or higher.
enumeration_type_ = kMMDeviceEnumeration;
// Task must be posted last to avoid races from handing out "this" to the
// audio thread.
GetMessageLoop()->PostTask(FROM_HERE, base::Bind(
&AudioManagerWin::CreateDeviceListener, base::Unretained(this)));
AudioManagerWin::~AudioManagerWin() {
// It's safe to post a task here since Shutdown() will wait for all tasks to
// complete before returning.
GetMessageLoop()->PostTask(FROM_HERE, base::Bind(
&AudioManagerWin::DestroyDeviceListener, base::Unretained(this)));
bool AudioManagerWin::HasAudioOutputDevices() {
return (::waveOutGetNumDevs() != 0);
bool AudioManagerWin::HasAudioInputDevices() {
return (::waveInGetNumDevs() != 0);
void AudioManagerWin::CreateDeviceListener() {
// AudioDeviceListenerWin must be initialized on a COM thread and should only
// be used if WASAPI / Core Audio is supported.
if (CoreAudioUtil::IsSupported()) {
output_device_listener_.reset(new AudioDeviceListenerWin(BindToLoop(
GetMessageLoop(), base::Bind(
void AudioManagerWin::DestroyDeviceListener() {
string16 AudioManagerWin::GetAudioInputDeviceModel() {
// Get the default audio capture device and its device interface name.
DWORD device_id = 0;
reinterpret_cast<DWORD_PTR>(&device_id), NULL);
ULONG device_interface_name_size = 0;
reinterpret_cast<DWORD_PTR>(&device_interface_name_size), 0);
size_t bytes_in_char16 = sizeof(string16::value_type);
DCHECK_EQ(0u, device_interface_name_size % bytes_in_char16);
if (device_interface_name_size <= bytes_in_char16)
return string16(); // No audio capture device.
string16 device_interface_name;
string16::value_type* name_ptr = WriteInto(&device_interface_name,
device_interface_name_size / bytes_in_char16);
// Enumerate all audio devices and find the one matching the above device
// interface name.
HDEVINFO device_info = SetupDiGetClassDevs(
if (device_info == INVALID_HANDLE_VALUE)
return string16();
DWORD interface_index = 0;
interface_data.cbSize = sizeof(interface_data);
while (SetupDiEnumDeviceInterfaces(device_info, 0, &AM_KSCATEGORY_AUDIO,
interface_index++, &interface_data)) {
// Query the size of the struct, allocate it and then query the data.
SP_DEVINFO_DATA device_data;
device_data.cbSize = sizeof(device_data);
DWORD interface_detail_size = 0;
SetupDiGetDeviceInterfaceDetail(device_info, &interface_data, 0, 0,
&interface_detail_size, &device_data);
if (!interface_detail_size)
scoped_ptr<char[]> interface_detail_buffer(new char[interface_detail_size]);
interface_detail->cbSize = interface_detail_size;
if (!SetupDiGetDeviceInterfaceDetail(device_info, &interface_data,
interface_detail_size, NULL,
return string16();
bool device_found = (device_interface_name == interface_detail->DevicePath);
if (device_found)
return GetDeviceAndDriverInfo(device_info, &device_data);
return string16();
void AudioManagerWin::ShowAudioInputSettings() {
std::wstring program;
std::string argument;
if (!CoreAudioUtil::IsSupported()) {
program = L"sndvol32.exe";
argument = "-R";
} else {
program = L"control.exe";
argument = "mmsys.cpl,,1";
base::FilePath path;
PathService::Get(base::DIR_SYSTEM, &path);
path = path.Append(program);
CommandLine command_line(path);
base::LaunchProcess(command_line, base::LaunchOptions(), NULL);
void AudioManagerWin::GetAudioDeviceNamesImpl(
bool input,
AudioDeviceNames* device_names) {
DCHECK(enumeration_type() != kUninitializedEnumeration);
// Enumerate all active audio-endpoint capture devices.
if (enumeration_type() == kWaveEnumeration) {
// Utilize the Wave API for Windows XP.
if (input)
} else {
// Utilize the MMDevice API (part of Core Audio) for Vista and higher.
if (input)
// Always add default device parameters as first element.
if (!device_names->empty()) {
AudioDeviceName name;
name.device_name = AudioManagerBase::kDefaultDeviceName;
name.unique_id = AudioManagerBase::kDefaultDeviceId;
void AudioManagerWin::GetAudioInputDeviceNames(AudioDeviceNames* device_names) {
GetAudioDeviceNamesImpl(true, device_names);
void AudioManagerWin::GetAudioOutputDeviceNames(
AudioDeviceNames* device_names) {
GetAudioDeviceNamesImpl(false, device_names);
AudioParameters AudioManagerWin::GetInputStreamParameters(
const std::string& device_id) {
int sample_rate = 48000;
ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
if (CoreAudioUtil::IsSupported()) {
int hw_sample_rate = WASAPIAudioInputStream::HardwareSampleRate(device_id);
if (hw_sample_rate)
sample_rate = hw_sample_rate;
channel_layout =
WASAPIAudioInputStream::HardwareChannelCount(device_id) == 1 ?
// TODO(Henrika): improve the default buffer size value for input stream.
return AudioParameters(
AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
sample_rate, 16, kFallbackBufferSize);
std::string AudioManagerWin::GetAssociatedOutputDeviceID(
const std::string& input_device_id) {
if (!CoreAudioUtil::IsSupported()) {
<< "GetAssociatedOutputDeviceID is not supported on this OS";
return std::string();
return CoreAudioUtil::GetMatchingOutputDeviceID(input_device_id);
// Factory for the implementations of AudioOutputStream for AUDIO_PCM_LINEAR
// mode.
// - PCMWaveOutAudioOutputStream: Based on the waveOut API.
AudioOutputStream* AudioManagerWin::MakeLinearOutputStream(
const AudioParameters& params) {
DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
if (params.channels() > kWinMaxChannels)
return NULL;
return new PCMWaveOutAudioOutputStream(this,
// Factory for the implementations of AudioOutputStream for
// AUDIO_PCM_LOW_LATENCY mode. Two implementations should suffice most
// windows user's needs.
// - PCMWaveOutAudioOutputStream: Based on the waveOut API.
// - WASAPIAudioOutputStream: Based on Core Audio (WASAPI) API.
AudioOutputStream* AudioManagerWin::MakeLowLatencyOutputStream(
const AudioParameters& params,
const std::string& device_id,
const std::string& input_device_id) {
DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
if (params.channels() > kWinMaxChannels)
return NULL;
if (!CoreAudioUtil::IsSupported()) {
// Fall back to Windows Wave implementation on Windows XP or lower.
DLOG_IF(ERROR, !device_id.empty() &&
device_id != AudioManagerBase::kDefaultDeviceId)
<< "Opening by device id not supported by PCMWaveOutAudioOutputStream";
DVLOG(1) << "Using WaveOut since WASAPI requires at least Vista.";
return new PCMWaveOutAudioOutputStream(
this, params, NumberOfWaveOutBuffers(), WAVE_MAPPER);
// TODO(rtoy): support more than stereo input.
if (params.input_channels() > 0) {
DVLOG(1) << "WASAPIUnifiedStream is created.";
DLOG_IF(ERROR, !device_id.empty() &&
device_id != AudioManagerBase::kDefaultDeviceId)
<< "Opening by device id not supported by WASAPIUnifiedStream";
return new WASAPIUnifiedStream(this, params, input_device_id);
// Pass an empty string to indicate that we want the default device
// since we consistently only check for an empty string in
// WASAPIAudioOutputStream.
return new WASAPIAudioOutputStream(this,
device_id == AudioManagerBase::kDefaultDeviceId ?
std::string() : device_id,
params, eConsole);
// Factory for the implementations of AudioInputStream for AUDIO_PCM_LINEAR
// mode.
AudioInputStream* AudioManagerWin::MakeLinearInputStream(
const AudioParameters& params, const std::string& device_id) {
DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
return CreatePCMWaveInAudioInputStream(params, device_id);
// Factory for the implementations of AudioInputStream for
AudioInputStream* AudioManagerWin::MakeLowLatencyInputStream(
const AudioParameters& params, const std::string& device_id) {
DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
AudioInputStream* stream = NULL;
if (!CoreAudioUtil::IsSupported()) {
// Fall back to Windows Wave implementation on Windows XP or lower.
DVLOG(1) << "Using WaveIn since WASAPI requires at least Vista.";
stream = CreatePCMWaveInAudioInputStream(params, device_id);
} else {
stream = new WASAPIAudioInputStream(this, params, device_id);
return stream;
std::string AudioManagerWin::GetDefaultOutputDeviceID() {
if (!CoreAudioUtil::IsSupported())
return std::string();
return CoreAudioUtil::GetDefaultOutputDeviceID();
AudioParameters AudioManagerWin::GetPreferredOutputStreamParameters(
const std::string& output_device_id,
const AudioParameters& input_params) {
const bool core_audio_supported = CoreAudioUtil::IsSupported();
DLOG_IF(ERROR, !core_audio_supported && !output_device_id.empty())
<< "CoreAudio is required to open non-default devices.";
const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
int sample_rate = 48000;
int buffer_size = kFallbackBufferSize;
int bits_per_sample = 16;
int input_channels = 0;
bool use_input_params = !core_audio_supported;
if (core_audio_supported) {
if (cmd_line->HasSwitch(switches::kEnableExclusiveAudio)) {
// TODO(rtoy): tune these values for best possible WebAudio
// performance. WebRTC works well at 48kHz and a buffer size of 480
// samples will be used for this case. Note that exclusive mode is
// experimental. This sample rate will be combined with a buffer size of
// 256 samples, which corresponds to an output delay of ~5.33ms.
sample_rate = 48000;
buffer_size = 256;
if (input_params.IsValid())
channel_layout = input_params.channel_layout();
} else {
AudioParameters params;
HRESULT hr = CoreAudioUtil::GetPreferredAudioParameters(
output_device_id.empty() ?
GetDefaultOutputDeviceID() : output_device_id,
if (SUCCEEDED(hr)) {
bits_per_sample = params.bits_per_sample();
buffer_size = params.frames_per_buffer();
channel_layout = params.channel_layout();
sample_rate = params.sample_rate();
} else {
use_input_params = true;
if (input_params.IsValid()) {
// If the user has enabled checking supported channel layouts or we don't
// have a valid channel layout yet, try to use the input layout. See bugs
// and for more details.
if (core_audio_supported &&
(cmd_line->HasSwitch(switches::kTrySupportedChannelLayouts) ||
channel_layout == CHANNEL_LAYOUT_UNSUPPORTED)) {
// Check if it is possible to open up at the specified input channel
// layout but avoid checking if the specified layout is the same as the
// hardware (preferred) layout. We do this extra check to avoid the
// CoreAudioUtil::IsChannelLayoutSupported() overhead in most cases.
if (input_params.channel_layout() != channel_layout) {
// TODO(henrika): Internally, IsChannelLayoutSupported does many of the
// operations that have already been done such as opening up a client
// and fetching the WAVEFORMATPCMEX format. Ideally we should only do
// that once. Then here, we can check the layout from the data we
// already hold.
if (CoreAudioUtil::IsChannelLayoutSupported(
output_device_id, eRender, eConsole,
input_params.channel_layout())) {
// Open up using the same channel layout as the source if it is
// supported by the hardware.
channel_layout = input_params.channel_layout();
VLOG(1) << "Hardware channel layout is not used; using same layout"
<< " as the source instead (" << channel_layout << ")";
input_channels = input_params.input_channels();
if (use_input_params) {
// If WASAPI isn't supported we'll fallback to WaveOut, which will take
// care of resampling and bits per sample changes. By setting these
// equal to the input values, AudioOutputResampler will skip resampling
// and bit per sample differences (since the input parameters will match
// the output parameters).
bits_per_sample = input_params.bits_per_sample();
buffer_size = input_params.frames_per_buffer();
channel_layout = input_params.channel_layout();
sample_rate = input_params.sample_rate();
int user_buffer_size = GetUserBufferSize();
if (user_buffer_size)
buffer_size = user_buffer_size;
return AudioParameters(
AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout, input_channels,
sample_rate, bits_per_sample, buffer_size);
AudioInputStream* AudioManagerWin::CreatePCMWaveInAudioInputStream(
const AudioParameters& params,
const std::string& device_id) {
std::string xp_device_id = device_id;
if (device_id != AudioManagerBase::kDefaultDeviceId &&
enumeration_type_ == kMMDeviceEnumeration) {
xp_device_id = ConvertToWinXPInputDeviceId(device_id);
if (xp_device_id.empty()) {
DLOG(ERROR) << "Cannot find a waveIn device which matches the device ID "
<< device_id;
return NULL;
return new PCMWaveInAudioInputStream(this, params, kNumInputBuffers,
/// static
AudioManager* CreateAudioManager() {
return new AudioManagerWin();
} // namespace media