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

media/audio/win/audio_low_latency_input_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_input_win.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "media/audio/win/audio_manager_win.h"
@@ skipping 33 matching lines @@
       started_(false),
       frame_size_(0),
       packet_size_frames_(0),
       packet_size_bytes_(0),
       endpoint_buffer_size_frames_(0),
       effects_(params.effects()),
       device_id_(device_id),
       perf_count_to_100ns_units_(0.0),
       ms_to_frame_count_(0.0),
       sink_(NULL),
+      com_stream_(NULL),
       audio_bus_(media::AudioBus::Create(params)) {
   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 87 matching lines @@
   if (started_)
     return;
 
   DCHECK(!sink_);
   sink_ = callback;
 
   // Starts periodic AGC microphone measurements if the AGC has been enabled
   // using SetAutomaticGainControl().
   StartAgc();
 
+  if (!MarshalComPointers()) {
+    HandleError(S_FALSE);
+    return;
+  }
+
   // Create and start the thread that will drive the capturing by waiting for
   // capture events.
   capture_thread_ =
       new base::DelegateSimpleThread(this, "wasapi_capture_thread");
   capture_thread_->Start();
 
   // Start streaming data between the endpoint buffer and the audio engine.
   HRESULT hr = audio_client_->Start();
   DLOG_IF(ERROR, FAILED(hr)) << "Failed to start input streaming.";
 
   if (SUCCEEDED(hr) && audio_render_client_for_loopback_.get())
     hr = audio_render_client_for_loopback_->Start();
 
   started_ = SUCCEEDED(hr);
+  if (!started_)
+    HandleError(hr);
 }
 
 void WASAPIAudioInputStream::Stop() {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "WASAPIAudioInputStream::Stop()";
   if (!started_)
     return;
 
   // Stops periodic AGC microphone measurements.
   StopAgc();
@@ skipping 158 matching lines @@
 
   ScopedComPtr<IAudioClient> audio_client;
   hr = endpoint_device->Activate(__uuidof(IAudioClient),
                                  CLSCTX_INPROC_SERVER,
                                  NULL,
                                  audio_client.ReceiveVoid());
   return SUCCEEDED(hr) ? audio_client->GetMixFormat(device_format) : hr;
 }
 
 void WASAPIAudioInputStream::Run() {
-  ScopedCOMInitializer com_init(ScopedCOMInitializer::kMTA);
+  ScopedCOMInitializer com_init;
 
   // Increase the thread priority.
   capture_thread_->SetThreadPriority(base::ThreadPriority::REALTIME_AUDIO);
 
   // Enable MMCSS to ensure that this thread receives prioritized access to
   // CPU resources.
   DWORD task_index = 0;
   HANDLE mm_task = avrt::AvSetMmThreadCharacteristics(L"Pro Audio",
                                                       &task_index);
   bool mmcss_is_ok =
       (mm_task && avrt::AvSetMmThreadPriority(mm_task, AVRT_PRIORITY_CRITICAL));
   if (!mmcss_is_ok) {
     // Failed to enable MMCSS on this thread. It is not fatal but can lead
     // to reduced QoS at high load.
     DWORD err = GetLastError();
     LOG(WARNING) << "Failed to enable MMCSS (error code=" << err << ").";
   }
 
+  // Retrieve COM pointers from the main thread.
+  IAudioCaptureClient* thread_audio_capture_client = NULL;
+
+  bool error = !UnmarshalComPointers(&thread_audio_capture_client);
+
   // Allocate a buffer with a size that enables us to take care of cases like:
   // 1) The recorded buffer size is smaller, or does not match exactly with,
   //    the selected packet size used in each callback.
   // 2) The selected buffer size is larger than the recorded buffer size in
   //    each event.
   size_t buffer_frame_index = 0;
   size_t capture_buffer_size = std::max(
       2 * endpoint_buffer_size_frames_ * frame_size_,
       2 * packet_size_frames_ * frame_size_);
   scoped_ptr<uint8[]> capture_buffer(new uint8[capture_buffer_size]);
 
   LARGE_INTEGER now_count;
   bool recording = true;
-  bool error = false;
-  double volume = GetVolume();
+  double volume = 0;
   HANDLE wait_array[2] =
       { stop_capture_event_.Get(), audio_samples_ready_event_.Get() };
 
   while (recording && !error) {
     HRESULT hr = S_FALSE;
 
     // Wait for a close-down event or a new capture event.
     DWORD wait_result = WaitForMultipleObjects(2, wait_array, FALSE, INFINITE);
     switch (wait_result) {
       case WAIT_FAILED:
         error = true;
         break;
       case WAIT_OBJECT_0 + 0:
         // |stop_capture_event_| has been set.
         recording = false;
         break;
       case WAIT_OBJECT_0 + 1:
         {
           // |audio_samples_ready_event_| has been set.
           BYTE* data_ptr = NULL;
           UINT32 num_frames_to_read = 0;
           DWORD flags = 0;
           UINT64 device_position = 0;
           UINT64 first_audio_frame_timestamp = 0;
 
           // Retrieve the amount of data in the capture endpoint buffer,
           // replace it with silence if required, create callbacks for each
           // packet and store non-delivered data for the next event.
-          hr = audio_capture_client_->GetBuffer(&data_ptr,
-                                                &num_frames_to_read,
-                                                &flags,
-                                                &device_position,
-                                                &first_audio_frame_timestamp);
+          hr = thread_audio_capture_client->GetBuffer(
+              &data_ptr, &num_frames_to_read, &flags, &device_position,
+              &first_audio_frame_timestamp);
           if (FAILED(hr)) {
             DLOG(ERROR) << "Failed to get data from the capture buffer";
             continue;
           }
 
           if (num_frames_to_read != 0) {
             size_t pos = buffer_frame_index * frame_size_;
             size_t num_bytes = num_frames_to_read * frame_size_;
             DCHECK_GE(capture_buffer_size, pos + num_bytes);
 
             if (flags & AUDCLNT_BUFFERFLAGS_SILENT) {
               // Clear out the local buffer since silence is reported.
               memset(&capture_buffer[pos], 0, num_bytes);
             } else {
               // Copy captured data from audio engine buffer to local buffer.
               memcpy(&capture_buffer[pos], data_ptr, num_bytes);
             }
 
             buffer_frame_index += num_frames_to_read;
           }
 
-          hr = audio_capture_client_->ReleaseBuffer(num_frames_to_read);
+          hr = thread_audio_capture_client->ReleaseBuffer(num_frames_to_read);
           DLOG_IF(ERROR, FAILED(hr)) << "Failed to release capture buffer";
 
           // Derive a delay estimate for the captured audio packet.
           // The value contains two parts (A+B), where A is the delay of the
           // first audio frame in the packet and B is the extra delay
           // contained in any stored data. Unit is in audio frames.
           QueryPerformanceCounter(&now_count);
           double audio_delay_frames =
               ((perf_count_to_100ns_units_ * now_count.QuadPart -
                 first_audio_frame_timestamp) / 10000.0) * ms_to_frame_count_ +
@@ skipping 217 matching lines @@
   // that glitches do not occur between the periodic processing passes.
   // This setting should lead to lowest possible latency.
   HRESULT hr = audio_client_->Initialize(
       AUDCLNT_SHAREMODE_SHARED,
       flags,
       0,  // hnsBufferDuration
       0,
       &format_,
       (effects_ & AudioParameters::DUCKING) ? &kCommunicationsSessionId : NULL);
 
-  if (FAILED(hr))
+  if (FAILED(hr)) {
+    PLOG(ERROR) << "Failed to initalize IAudioClient: " << std::hex << hr
+                << " : ";
     return hr;
+  }
 
   // Retrieve the length of the endpoint buffer shared between the client
   // and the audio engine. The buffer length determines the maximum amount
   // of capture data that the audio engine can read from the endpoint buffer
   // during a single processing pass.
   // A typical value is 960 audio frames <=> 20ms @ 48kHz sample rate.
   hr = audio_client_->GetBufferSize(&endpoint_buffer_size_frames_);
   if (FAILED(hr))
     return hr;
 
@@ skipping 70 matching lines @@
   if (FAILED(hr))
     return hr;
 
   // Obtain a reference to the ISimpleAudioVolume interface which enables
   // us to control the master volume level of an audio session.
   hr = audio_client_->GetService(__uuidof(ISimpleAudioVolume),
                                  simple_audio_volume_.ReceiveVoid());
   return hr;
 }
 
+bool WASAPIAudioInputStream::MarshalComPointers() {
+  HRESULT hr = CoMarshalInterThreadInterfaceInStream(
+      __uuidof(IAudioCaptureClient), audio_capture_client_.get(), &com_stream_);
+  if (FAILED(hr))
+    DLOG(ERROR) << "Marshal failed for IAudioCaptureClient: " << std::hex << hr;
+  DCHECK(com_stream_);
+  return SUCCEEDED(hr);
+}
+
+bool WASAPIAudioInputStream::UnmarshalComPointers(
+    IAudioCaptureClient** audio_capture_client) {
+  HRESULT hr = CoGetInterfaceAndReleaseStream(
+      com_stream_, __uuidof(IAudioCaptureClient),
+      reinterpret_cast<LPVOID*>(audio_capture_client));
+  com_stream_ = NULL;
+  if (FAILED(hr))
+    DLOG(ERROR) << "Unmarshal failed IAudioCaptureClient: " << std::hex << hr;
+  return SUCCEEDED(hr);
+}
+
 }  // namespace media