Adds input device selection on Windows.

media/audio/win/audio_low_latency_input_win.cc

 // Copyright (c) 2011 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_input_win.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/win/audio_manager_win.h"
 #include "media/audio/win/avrt_wrapper_win.h"
 
 using base::win::ScopedComPtr;
 using base::win::ScopedCOMInitializer;
 
 WASAPIAudioInputStream::WASAPIAudioInputStream(
-    AudioManagerWin* manager, const AudioParameters& params, ERole device_role)
+    AudioManagerWin* manager, const AudioParameters& params,
+    const std::string& device_id)
     : com_init_(ScopedCOMInitializer::kMTA),
       manager_(manager),
       capture_thread_(NULL),
       opened_(false),
       started_(false),
       endpoint_buffer_size_frames_(0),
-      device_role_(device_role),
+      device_id_(device_id),
       sink_(NULL) {
   DCHECK(manager_);
 
   // 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 capture format specified by the client.
   format_.nSamplesPerSec = params.sample_rate;
   format_.wFormatTag = WAVE_FORMAT_PCM;
@@ skipping 35 matching lines @@
   }
 }
 
 WASAPIAudioInputStream::~WASAPIAudioInputStream() {}
 
 bool WASAPIAudioInputStream::Open() {
   // Verify that we are not already opened.
   if (opened_)
     return false;
 
-  // Obtain a reference to the IMMDevice interface of the default capturing
-  // device with the specified role.
-  HRESULT hr = SetCaptureDevice(device_role_);
+  // Obtain a reference to the IMMDevice interface of the capturing
+  // device with the specified unique identifier or role which was
+  // set at construction.
+  HRESULT hr = SetCaptureDevice();
   if (FAILED(hr)) {
     return false;
   }
 
   // Obtain an IAudioClient interface which enables us to create and initialize
   // an audio stream between an audio application and the audio engine.
   hr = ActivateCaptureDevice();
   if (FAILED(hr)) {
     return false;
   }
@@ skipping 278 matching lines @@
     PLOG(WARNING) << "Failed to disable MMCSS";
   }
 }
 
 void WASAPIAudioInputStream::HandleError(HRESULT err) {
   NOTREACHED() << "Error code: " << err;
   if (sink_)
     sink_->OnError(this, static_cast<int>(err));
 }
 
-HRESULT WASAPIAudioInputStream::SetCaptureDevice(ERole device_role) {
+HRESULT WASAPIAudioInputStream::SetCaptureDevice() {
   ScopedComPtr<IMMDeviceEnumerator> enumerator;
   HRESULT hr =  CoCreateInstance(__uuidof(MMDeviceEnumerator),
                                  NULL,
                                  CLSCTX_INPROC_SERVER,
                                  __uuidof(IMMDeviceEnumerator),
                                  enumerator.ReceiveVoid());
   if (SUCCEEDED(hr)) {
-    // Retrieve the default capture audio endpoint for the specified role.
-    // Note that, in Windows Vista, the MMDevice API supports device roles
-    // but the system-supplied user interface programs do not.
-    hr = enumerator->GetDefaultAudioEndpoint(eCapture,
-                                             device_role,
-                                             endpoint_device_.Receive());
+    // Retrieve the IMMDevice by using the specified role or the specified
+    // unique endpoint device-identification string.
+    // TODO(henrika): possibly add suport for the eCommunications as well.
+    if (device_id_ == AudioManagerBase::kDefaultDeviceId) {
+      // Retrieve the default capture audio endpoint for the specified role.
+      // Note that, in Windows Vista, the MMDevice API supports device roles
+      // but the system-supplied user interface programs do not.
+      hr = enumerator->GetDefaultAudioEndpoint(eCapture,
+                                               eConsole,
+                                               endpoint_device_.Receive());
+    } else {
+      // Retrieve a capture endpoint device that is specified by an endpoint
+      // device-identification string.
+      hr = enumerator->GetDevice(UTF8ToUTF16(device_id_).c_str(),
+                                 endpoint_device_.Receive());
+    }
 
-    // Verify that the audio endpoint device is active. That is, the audio
+    if (FAILED(hr))
+      return hr;
+
+    // Verify that the audio endpoint device is active, i.e., the audio
     // adapter that connects to the endpoint device is present and enabled.
     DWORD state = DEVICE_STATE_DISABLED;
     hr = endpoint_device_->GetState(&state);
     if (SUCCEEDED(hr)) {
       if (!(state & DEVICE_STATE_ACTIVE)) {
         DLOG(ERROR) << "Selected capture device is not active.";
         hr = E_ACCESSDENIED;
       }
     }
   }
@@ skipping 91 matching lines @@
   hr = audio_client_->SetEventHandle(audio_samples_ready_event_.Get());
   if (FAILED(hr))
     return hr;
 
   // Get access to the IAudioCaptureClient interface. This interface
   // enables us to read input data from the capture endpoint buffer.
   hr = audio_client_->GetService(__uuidof(IAudioCaptureClient),
                                  audio_capture_client_.ReceiveVoid());
   return hr;
 }