Switch to STA mode for audio thread and WASAPI I/O streams.

media/audio/win/audio_low_latency_input_win.h

 // 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.
 //
 // Implementation of AudioInputStream for Windows using Windows Core Audio
 // WASAPI for low latency capturing.
 //
 // Overview of operation:
 //
 // - An object of WASAPIAudioInputStream is created by the AudioManager
@@ skipping 113 matching lines @@
   HRESULT InitializeAudioEngine();
 
   // Retrieves the stream format that the audio engine uses for its internal
   // processing/mixing of shared-mode streams.
   // |effects| is a an AudioParameters::effects() flag that will have the
   // DUCKING flag raised for only the default communication device.
   static HRESULT GetMixFormat(const std::string& device_id,
                               WAVEFORMATEX** device_format,
                               int* effects);
 
+  // Handles sharing of COM pointers between the audio and capture threads.  The
+  // marshal method must be called on the audio manager thread, while unmarshal
+  // must be called on |capture_thread_|.
+  bool MarshalComPointers();
+  bool UnmarshalComPointers(
+      base::win::ScopedComPtr<IAudioCaptureClient>* audio_capture_client);
+
   // Our creator, the audio manager needs to be notified when we close.
   AudioManagerWin* manager_;
 
   // Capturing is driven by this thread (which has no message loop).
   // All OnData() callbacks will be called from this thread.
   base::DelegateSimpleThread* capture_thread_;
 
   // Contains the desired audio format which is set up at construction.
   WAVEFORMATEX format_;
 
@@ skipping 28 matching lines @@
   // Converts a raw performance counter value to 100-nanosecond unit.
   double perf_count_to_100ns_units_;
 
   // Conversion factor used in delay-estimation calculations.
   // Converts from milliseconds to audio frames.
   double ms_to_frame_count_;
 
   // Pointer to the object that will receive the recorded audio samples.
   AudioInputCallback* sink_;
 
+  // ------------------------------------------------------
+  // Warning: COM pointers must be marshaled from the audio thread to be used
+  // on any other thread. Do not use any of these interfaces on a thread other
+  // than the audio thread.  See MarshalComPointers() and UnmarshalComPointers()
+  // for marshaling pointers to the capture thread.
+
+  // Stream into which the COM pointers below are marshaled so that they can
+  // be used on another thread.
+  base::win::ScopedComPtr<IStream> com_stream_;
+
   // Windows Multimedia Device (MMDevice) API interfaces.
-
   // An IMMDevice interface which represents an audio endpoint device.
   base::win::ScopedComPtr<IMMDevice> endpoint_device_;
 
   // Windows Audio Session API (WASAPI) interfaces.
 
   // An IAudioClient interface which enables a client to create and initialize
   // an audio stream between an audio application and the audio engine.
   base::win::ScopedComPtr<IAudioClient> audio_client_;
 
   // Loopback IAudioClient doesn't support event-driven mode, so a separate
   // IAudioClient is needed to receive notifications when data is available in
   // the buffer. For loopback input |audio_client_| is used to receive data,
   // while |audio_render_client_for_loopback_| is used to get notifications
   // when a new buffer is ready. See comment in InitializeAudioEngine() for
   // details.
   base::win::ScopedComPtr<IAudioClient> audio_render_client_for_loopback_;
 
-  // The IAudioCaptureClient interface enables a client to read input data
-  // from a capture endpoint buffer.
-  base::win::ScopedComPtr<IAudioCaptureClient> audio_capture_client_;
-
   // The ISimpleAudioVolume interface enables a client to control the
   // master volume level of an audio session.
   // The volume-level is a value in the range 0.0 to 1.0.
   // This interface does only work with shared-mode streams.
   base::win::ScopedComPtr<ISimpleAudioVolume> simple_audio_volume_;
 
+  // The IAudioCaptureClient interface enables a client to read input data
+  // from a capture endpoint buffer.
+  base::win::ScopedComPtr<IAudioCaptureClient> audio_capture_client_;
+  // ------------------------------------------------------
+
   // The audio engine will signal this event each time a buffer has been
   // recorded.
   base::win::ScopedHandle audio_samples_ready_event_;
 
   // This event will be signaled when capturing shall stop.
   base::win::ScopedHandle stop_capture_event_;
 
   // Extra audio bus used for storage of deinterleaved data for the OnData
   // callback.
   scoped_ptr<media::AudioBus> audio_bus_;
 
   DISALLOW_COPY_AND_ASSIGN(WASAPIAudioInputStream);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_WIN_AUDIO_LOW_LATENCY_INPUT_WIN_H_