Don't start WASAPI render thread until setup completes.

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 53 matching lines @@
 
   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),
+      format_(),
       opened_(false),
       audio_parameters_are_valid_(false),
       volume_(1.0),
+      packet_size_frames_(0),
+      packet_size_bytes_(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)
@@ skipping 36 matching lines @@
 
   // Add the parts which are unique to WAVE_FORMAT_EXTENSIBLE.
   format_.Samples.wValidBitsPerSample = params.bits_per_sample();
   format_.dwChannelMask = CoreAudioUtil::GetChannelConfig(device_id, eRender);
   format_.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 
   // Store size (in different units) of audio packets which we expect to
   // get from the audio endpoint device in each render event.
   packet_size_frames_ = params.frames_per_buffer();
   packet_size_bytes_ = params.GetBytesPerBuffer();
-  packet_size_ms_ = (1000.0 * packet_size_frames_) / params.sample_rate();
   VLOG(1) << "Number of bytes per audio frame  : " << format->nBlockAlign;
   VLOG(1) << "Number of audio frames per packet: " << packet_size_frames_;
   VLOG(1) << "Number of bytes per packet       : " << packet_size_bytes_;
-  VLOG(1) << "Number of milliseconds per packet: " << packet_size_ms_;
+  VLOG(1) << "Number of milliseconds per packet: "
+          << params.GetBufferDuration().InMillisecondsF();
 
   // All events are auto-reset events and non-signaled initially.
 
   // Create the event which the audio engine will signal each time
   // a buffer becomes ready to be processed by the client.
   audio_samples_render_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
   DCHECK(audio_samples_render_event_.IsValid());
 
   // Create the event which will be set in Stop() when capturing shall stop.
   stop_render_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
@@ skipping 79 matching lines @@
   // a rendering endpoint buffer.
   ScopedComPtr<IAudioRenderClient> audio_render_client =
       CoreAudioUtil::CreateRenderClient(audio_client);
   if (!audio_render_client)
     return false;
 
    // Store valid COM interfaces.
   audio_client_ = audio_client;
   audio_render_client_ = audio_render_client;
 
+  hr = audio_client_->GetService(__uuidof(IAudioClock),
+                                 audio_clock_.ReceiveVoid());
+  if (FAILED(hr)) {
+    LOG(ERROR) << "Failed to get IAudioClock service.";
+    return false;
+  }
+
   opened_ = true;
   return true;
 }
 
 void WASAPIAudioOutputStream::Start(AudioSourceCallback* callback) {
   VLOG(1) << "WASAPIAudioOutputStream::Start()";
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
   CHECK(callback);
   CHECK(opened_);
 
   if (render_thread_) {
     CHECK_EQ(callback, source_);
     return;
   }
 
   source_ = callback;
 
+  // Ensure that the endpoint buffer is prepared with silence.
+  if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
+    if (!CoreAudioUtil::FillRenderEndpointBufferWithSilence(
+             audio_client_, audio_render_client_)) {
+      LOG(ERROR) << "Failed to prepare endpoint buffers with silence.";
+      callback->OnError(this);
+      return;
+    }
+  }
+  num_written_frames_ = endpoint_buffer_size_frames_;
+
   // Create and start the thread that will drive the rendering by waiting for
   // render events.
   render_thread_.reset(
       new base::DelegateSimpleThread(this, "wasapi_render_thread"));
   render_thread_->Start();
   if (!render_thread_->HasBeenStarted()) {
     LOG(ERROR) << "Failed to start WASAPI render thread.";
     StopThread();
     callback->OnError(this);
     return;
   }
 
-  // Ensure that the endpoint buffer is prepared with silence.
-  if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
-    if (!CoreAudioUtil::FillRenderEndpointBufferWithSilence(
-             audio_client_, audio_render_client_)) {
-      LOG(ERROR) << "Failed to prepare endpoint buffers with silence.";
-      StopThread();
-      callback->OnError(this);
-      return;
-    }
-  }
-  num_written_frames_ = endpoint_buffer_size_frames_;
-
   // Start streaming data between the endpoint buffer and the audio engine.
   HRESULT hr = audio_client_->Start();
   if (FAILED(hr)) {
     LOG_GETLASTERROR(ERROR)
         << "Failed to start output streaming: " << std::hex << hr;
     StopThread();
     callback->OnError(this);
   }
 }
 
@@ skipping 82 matching lines @@
   }
 
   HRESULT hr = S_FALSE;
 
   bool playing = true;
   bool error = false;
   HANDLE wait_array[] = { stop_render_event_,
                           audio_samples_render_event_ };
   UINT64 device_frequency = 0;
 
-  // The IAudioClock interface enables us to monitor a stream's data
-  // rate and the current position in the stream. Allocate it before we
-  // start spinning.
-  ScopedComPtr<IAudioClock> audio_clock;
-  hr = audio_client_->GetService(__uuidof(IAudioClock),
-                                 audio_clock.ReceiveVoid());
-  if (SUCCEEDED(hr)) {
-    // The device frequency is the frequency generated by the hardware clock in
-    // the audio device. The GetFrequency() method reports a constant frequency.
-    hr = audio_clock->GetFrequency(&device_frequency);
-  }
+  // The device frequency is the frequency generated by the hardware clock in
+  // the audio device. The GetFrequency() method reports a constant frequency.
+  hr = audio_clock_->GetFrequency(&device_frequency);
   error = FAILED(hr);
   PLOG_IF(ERROR, error) << "Failed to acquire IAudioClock interface: "
                         << std::hex << hr;
 
   // Keep rendering audio until the stop event or the stream-switch event
   // is signaled. An error event can also break the main thread loop.
   while (playing && !error) {
     // Wait for a close-down event, stream-switch event or a new render event.
     DWORD wait_result = WaitForMultipleObjects(arraysize(wait_array),
                                                wait_array,
                                                FALSE,
                                                INFINITE);
 
     switch (wait_result) {
       case WAIT_OBJECT_0 + 0:
         // |stop_render_event_| has been set.
         playing = false;
         break;
       case WAIT_OBJECT_0 + 1:
         // |audio_samples_render_event_| has been set.
-        error = !RenderAudioFromSource(audio_clock, device_frequency);
+        error = !RenderAudioFromSource(device_frequency);
         break;
       default:
         error = true;
         break;
     }
   }
 
   if (playing && error) {
     // Stop audio rendering since something has gone wrong in our main thread
     // loop. Note that, we are still in a "started" state, hence a Stop() call
     // is required to join the thread properly.
     audio_client_->Stop();
     PLOG(ERROR) << "WASAPI rendering failed.";
   }
 
   // Disable MMCSS.
   if (mm_task && !avrt::AvRevertMmThreadCharacteristics(mm_task)) {
     PLOG(WARNING) << "Failed to disable MMCSS";
   }
 }
 
-bool WASAPIAudioOutputStream::RenderAudioFromSource(
-    IAudioClock* audio_clock, UINT64 device_frequency) {
+bool WASAPIAudioOutputStream::RenderAudioFromSource(UINT64 device_frequency) {
   TRACE_EVENT0("audio", "RenderAudioFromSource");
 
   HRESULT hr = S_FALSE;
   UINT32 num_queued_frames = 0;
   uint8* audio_data = NULL;
 
   // Contains how much new data we can write to the buffer without
   // the risk of overwriting previously written data that the audio
   // engine has not yet read from the buffer.
   size_t num_available_frames = 0;
@@ skipping 51 matching lines @@
       return false;
     }
 
     // Derive the audio delay which corresponds to the delay between
     // a render event and the time when the first audio sample in a
     // packet is played out through the speaker. This delay value
     // can typically be utilized by an acoustic echo-control (AEC)
     // unit at the render side.
     UINT64 position = 0;
     int audio_delay_bytes = 0;
-    hr = audio_clock->GetPosition(&position, NULL);
+    hr = audio_clock_->GetPosition(&position, NULL);
     if (SUCCEEDED(hr)) {
       // Stream position of the sample that is currently playing
       // through the speaker.
       double pos_sample_playing_frames = format_.Format.nSamplesPerSec *
           (static_cast<double>(position) / device_frequency);
 
       // Stream position of the last sample written to the endpoint
       // buffer. Note that, the packet we are about to receive in
       // the upcoming callback is also included.
       size_t pos_last_sample_written_frames =
@@ skipping 129 matching lines @@
 
     // Ensure that we don't quit the main thread loop immediately next
     // time Start() is called.
     ResetEvent(stop_render_event_.Get());
   }
 
   source_ = NULL;
 }
 
 }  // namespace media