Wire up the output device id and provide an implementation on Windows.

media/audio/win/audio_low_latency_output_win.cc

 // 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/win/audio_low_latency_output_win.h"
 
 #include <Functiondiscoverykeys_devpkey.h>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 112 matching lines @@
     client = CoreAudioUtil::CreateClient(device);
   }
 
   if (!client || FAILED(CoreAudioUtil::GetSharedModeMixFormat(client, &format)))
     return 0;
 
   return static_cast<int>(format.Format.nSamplesPerSec);
 }
 
 WASAPIAudioOutputStream::WASAPIAudioOutputStream(AudioManagerWin* manager,
+                                                 const std::string& device_id,
                                                  const AudioParameters& params,
                                                  ERole device_role)
     : creating_thread_id_(base::PlatformThread::CurrentId()),
       manager_(manager),
       opened_(false),
       audio_parameters_are_valid_(false),
       volume_(1.0),
       endpoint_buffer_size_frames_(0),
+      device_id_(device_id),
       device_role_(device_role),
       share_mode_(GetShareMode()),
       num_written_frames_(0),
       source_(NULL),
       audio_bus_(AudioBus::Create(params)) {
   DCHECK(manager_);
   VLOG(1) << "WASAPIAudioOutputStream::WASAPIAudioOutputStream()";
   VLOG_IF(1, share_mode_ == AUDCLNT_SHAREMODE_EXCLUSIVE)
       << "Core Audio (WASAPI) EXCLUSIVE MODE is enabled.";
 
   if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
     // Verify that the input audio parameters are identical (bit depth and
     // channel count are excluded) to the preferred (native) audio parameters.
     // Open() will fail if this is not the case.
     AudioParameters preferred_params;
-    HRESULT hr = CoreAudioUtil::GetPreferredAudioParameters(
-        eRender, device_role, &preferred_params);
+    HRESULT hr = device_id_.empty() ?
+        CoreAudioUtil::GetPreferredAudioParameters(eRender, device_role,
+                                                   &preferred_params) :
+        CoreAudioUtil::GetPreferredAudioParameters(device_id_,
+                                                   &preferred_params);
     audio_parameters_are_valid_ = SUCCEEDED(hr) &&
         CompareAudioParametersNoBitDepthOrChannels(params, preferred_params);
     LOG_IF(WARNING, !audio_parameters_are_valid_)
-        << "Input and preferred parameters are not identical.";
+        << "Input and preferred parameters are not identical. "
+        << "Device id: " << device_id_;
   }
 
   // Load the Avrt DLL if not already loaded. Required to support MMCSS.
   bool avrt_init = avrt::Initialize();
   DCHECK(avrt_init) << "Failed to load the avrt.dll";
 
   // Set up the desired render format specified by the client. We use the
   // WAVE_FORMAT_EXTENSIBLE structure to ensure that multiple channel ordering
   // and high precision data can be supported.
 
@@ skipping 35 matching lines @@
 }
 
 WASAPIAudioOutputStream::~WASAPIAudioOutputStream() {}
 
 bool WASAPIAudioOutputStream::Open() {
   VLOG(1) << "WASAPIAudioOutputStream::Open()";
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
   if (opened_)
     return true;
 
-
   // Audio parameters must be identical to the preferred set of parameters
   // if shared mode (default) is utilized.
   if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
     if (!audio_parameters_are_valid_) {
       LOG(ERROR) << "Audio parameters are not valid.";
       return false;
     }
   }
 
   // Create an IAudioClient interface for the default rendering IMMDevice.
-  ScopedComPtr<IAudioClient> audio_client =
-      CoreAudioUtil::CreateDefaultClient(eRender, device_role_);
+  ScopedComPtr<IAudioClient> audio_client;
+  if (device_id_.empty()) {
+    audio_client = CoreAudioUtil::CreateDefaultClient(eRender, device_role_);
+  } else {
+    ScopedComPtr<IMMDevice> device(CoreAudioUtil::CreateDevice(device_id_));
+    DLOG_IF(ERROR, !device) << "Failed to open device: " << device_id_;
+    if (device)
+      audio_client = CoreAudioUtil::CreateClient(device);
+  }
+
   if (!audio_client)
     return false;
 
   // Extra sanity to ensure that the provided device format is still valid.
   if (!CoreAudioUtil::IsFormatSupported(audio_client,
                                         share_mode_,
                                         &format_)) {
     return false;
   }
 
@@ skipping 447 matching lines @@
     VLOG(1) << "IAudioClient::GetBufferSize: " << std::hex << hr;
     return hr;
   }
 
   *endpoint_buffer_size = buffer_size_in_frames;
   VLOG(2) << "endpoint buffer size: " << buffer_size_in_frames;
   return hr;
 }
 
 }  // namespace media