Adds input device selection on Windows.

media/audio/win/wavein_input_win.h

 // 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.
 
 #ifndef MEDIA_AUDIO_WIN_WAVEIN_INPUT_WIN_H_
 #define MEDIA_AUDIO_WIN_WAVEIN_INPUT_WIN_H_
 
 #include <windows.h>
 #include <mmsystem.h>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/win/scoped_handle.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_parameters.h"
 
 class AudioManagerWin;
 
 class PCMWaveInAudioInputStream : public AudioInputStream {
  public:
   // The ctor takes all the usual parameters, plus |manager| which is the
   // the audio manager who is creating this object and |device_id| which
   // is provided by the operating system.
   PCMWaveInAudioInputStream(AudioManagerWin* manager,
                             const AudioParameters& params,
                             int num_buffers,
-                            UINT device_id);
+                            const std::string& device_id);
   virtual ~PCMWaveInAudioInputStream();
 
   // Implementation of AudioInputStream.
   virtual bool Open() OVERRIDE;
   virtual void Start(AudioInputCallback* callback) OVERRIDE;
   virtual void Stop() OVERRIDE;
   virtual void Close() OVERRIDE;
 
  private:
   enum State {
@@ skipping 16 matching lines @@
 
   // Allocates and prepares the memory that will be used for recording.
   void SetupBuffers();
 
   // Deallocates the memory allocated in SetupBuffers.
   void FreeBuffers();
 
   // Sends a buffer to the audio driver for recording.
   void QueueNextPacket(WAVEHDR* buffer);
 
+  // Converts the stored device id string into an unsigned integer which
+  // can be used by waveInOpen() to open the specified capture device.
+  bool GetDeviceId(UINT* device_index);
+
   // Reader beware. Visual C has stronger guarantees on volatile vars than
   // most people expect. In fact, it has release semantics on write and
   // acquire semantics on reads. See the msdn documentation.
   volatile State state_;
 
   // The audio manager that created this input stream. We notify it when
   // we close so it can release its own resources.
   AudioManagerWin* manager_;
 
   // We use the callback mostly to periodically give the recorded audio data.
   AudioInputCallback* callback_;
 
   // The number of buffers of size |buffer_size_| each to use.
   const int num_buffers_;
 
   // The size in bytes of each audio buffer.
   uint32 buffer_size_;
 
   // Channels, 1 or 2.
   const int channels_;
 
-  // The id assigned by the operating system to the selected wave output
-  // hardware device. Usually this is just -1 which means 'default device'.
-  UINT device_id_;
+  // Contains the unique name of the selected endpoint device.
+  // Note that AudioManagerBase::kDefaultDeviceId represents the default
+  // device role and is not a valid ID as such.
+  std::string device_id_;
 
   // Windows native structure to encode the format parameters.
   WAVEFORMATEX format_;
 
   // Handle to the instance of the wave device.
   HWAVEIN wavein_;
 
   // Pointer to the first allocated audio buffer. This object owns it.
   WAVEHDR* buffer_;
 
   // An event that is signaled when the callback thread is ready to stop.
   base::win::ScopedHandle stopped_event_;
 
   DISALLOW_COPY_AND_ASSIGN(PCMWaveInAudioInputStream);
 };
 
 #endif  // MEDIA_AUDIO_WIN_WAVEIN_INPUT_WIN_H_