Avoids irregular OnMoreData callbacks on Windows using Core Audio

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"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.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"
+#include "media/audio/win/core_audio_util_win.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 
 using base::win::ScopedComPtr;
 using base::win::ScopedCOMInitializer;
 using base::win::ScopedCoMem;
 
 namespace media {
 
 typedef uint32 ChannelConfig;
 
-// Retrieves the stream format that the audio engine uses for its internal
-// processing/mixing of shared-mode streams.
-static HRESULT GetMixFormat(ERole device_role, WAVEFORMATEX** device_format) {
-  // Note that we are using the IAudioClient::GetMixFormat() API to get the
-  // device format in this function. It is in fact possible to be "more native",
-  // and ask the endpoint device directly for its properties. Given a reference
-  // to the IMMDevice interface of an endpoint object, a client can obtain a
-  // reference to the endpoint object's property store by calling the
-  // IMMDevice::OpenPropertyStore() method. However, I have not been able to
-  // access any valuable information using this method on my HP Z600 desktop,
-  // hence it feels more appropriate to use the IAudioClient::GetMixFormat()
-  // approach instead.
-
-  // Calling this function only makes sense for shared mode streams, since
-  // if the device will be opened in exclusive mode, then the application
-  // specified format is used instead. However, the result of this method can
-  // be useful for testing purposes so we don't DCHECK here.
-  DLOG_IF(WARNING, WASAPIAudioOutputStream::GetShareMode() ==
-          AUDCLNT_SHAREMODE_EXCLUSIVE) <<
-      "The mixing sample rate will be ignored for exclusive-mode streams.";
-
-  // It is assumed that this static method is called from a COM thread, i.e.,
-  // CoInitializeEx() is not called here again to avoid STA/MTA conflicts.
-  ScopedComPtr<IMMDeviceEnumerator> enumerator;
-  HRESULT hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
-                                NULL,
-                                CLSCTX_INPROC_SERVER,
-                                __uuidof(IMMDeviceEnumerator),
-                                enumerator.ReceiveVoid());
-  if (FAILED(hr))
-    return hr;
-
-  ScopedComPtr<IMMDevice> endpoint_device;
-  hr = enumerator->GetDefaultAudioEndpoint(eRender,
-                                           device_role,
-                                           endpoint_device.Receive());
-  if (FAILED(hr))
-    return hr;
-
-  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;
+// Compare two sets of audio parameters and return true if they are equal.
+// Note that bits_per_sample() is excluded from this comparison since Core
+// Audio can deal with most bit depths. As an example, if the native/mixing
+// bit depth is 32 bits (default), opening at 16 or 24 still works fine and
+// the audio engine will do the required conversion for us.
+static bool CompareAudioParameters(const media::AudioParameters& a,

[DaleCurtis, 2013/01/31 02:34:33]

Worth adding as a Equals() method on AudioParameters itself?

[tommi (sloooow) - chröme, 2013/01/31 13:42:08]

Since this doesn't compare all the properties such an Equal method would have to
accept a 'fields' flag or some such.
That seems like overkill if this is the only place where we do this comparison. 
Suggest for now to just rename the function CompareAudioParametersNoBitDepth to
make the purpose clearer.

[henrika (OOO until Aug 14), 2013/01/31 14:29:38]

I don't know if that is kocher actually since I don't compare all fields. I can
create a method with a more suitable name though.

[henrika (OOO until Aug 14), 2013/01/31 14:29:38]

Done.

+                                   const media::AudioParameters& b) {
+  return (a.format() == b.format() &&
+          a.channels() == b.channels() &&
+          a.sample_rate() == b.sample_rate() &&
+          a.frames_per_buffer() == b.frames_per_buffer());
 }
 
 // Retrieves an integer mask which corresponds to the channel layout the
 // audio engine uses for its internal processing/mixing of shared-mode
 // streams. This mask indicates which channels are present in the multi-
 // channel stream. The least significant bit corresponds with the Front Left
 // speaker, the next least significant bit corresponds to the Front Right
 // speaker, and so on, continuing in the order defined in KsMedia.h.
 // See http://msdn.microsoft.com/en-us/library/windows/hardware/ff537083(v=vs.85).aspx
 // for more details.
 static ChannelConfig GetChannelConfig() {
-  // Use a WAVEFORMATEXTENSIBLE structure since it can specify both the
-  // number of channels and the mapping of channels to speakers for
-  // multichannel devices.
-  base::win::ScopedCoMem<WAVEFORMATPCMEX> format_ex;
-  HRESULT hr = S_FALSE;
-  hr = GetMixFormat(eConsole, reinterpret_cast<WAVEFORMATEX**>(&format_ex));
+  ScopedComPtr<IAudioClient> client;

[tommi (sloooow) - chröme, 2013/01/31 13:42:08]

nit: pass the return value of CreateDefaultClient to the constructor.

[henrika (OOO until Aug 14), 2013/01/31 14:29:38]

These methods are modified. Please check again. Very advanced now ;-)

+  client = CoreAudioUtil::CreateDefaultClient(eRender, eConsole);
+  if (!client)
+    return 0;
+
+  WAVEFORMATPCMEX format;
+  HRESULT hr = CoreAudioUtil::GetSharedModeMixFormat(client, &format);
   if (FAILED(hr))
     return 0;
 
   // The dwChannelMask member specifies which channels are present in the
   // multichannel stream. The least significant bit corresponds to the
   // front left speaker, the next least significant bit corresponds to the
   // front right speaker, and so on.
   // See http://msdn.microsoft.com/en-us/library/windows/desktop/dd757714(v=vs.85).aspx
   // for more details on the channel mapping.
-  DVLOG(2) << "dwChannelMask: 0x" << std::hex << format_ex->dwChannelMask;
-
-#if !defined(NDEBUG)
-  // See http://en.wikipedia.org/wiki/Surround_sound for more details on
-  // how to name various speaker configurations. The list below is not complete.
-  const char* speaker_config = "Undefined";
-  switch (format_ex->dwChannelMask) {
-    case KSAUDIO_SPEAKER_MONO:
-      speaker_config = "Mono";
-      break;
-    case KSAUDIO_SPEAKER_STEREO:
-      speaker_config = "Stereo";
-      break;
-    case KSAUDIO_SPEAKER_5POINT1_SURROUND:
-      speaker_config = "5.1 surround";
-      break;
-    case KSAUDIO_SPEAKER_5POINT1:
-      speaker_config = "5.1";
-      break;
-    case KSAUDIO_SPEAKER_7POINT1_SURROUND:
-      speaker_config = "7.1 surround";
-      break;
-    case KSAUDIO_SPEAKER_7POINT1:
-      speaker_config = "7.1";
-      break;
-    default:
-      break;
-  }
-  DVLOG(2) << "speaker configuration: " << speaker_config;
-#endif
-
-  return static_cast<ChannelConfig>(format_ex->dwChannelMask);
+  DVLOG(2) << "dwChannelMask: 0x" << std::hex << format.dwChannelMask;
+  return static_cast<ChannelConfig>(format.dwChannelMask);
 }
 
 // Converts Microsoft's channel configuration to ChannelLayout.
 // This mapping is not perfect but the best we can do given the current
 // ChannelLayout enumerator and the Windows-specific speaker configurations
 // defined in ksmedia.h. Don't assume that the channel ordering in
 // ChannelLayout is exactly the same as the Windows specific configuration.
 // As an example: KSAUDIO_SPEAKER_7POINT1_SURROUND is mapped to
 // CHANNEL_LAYOUT_7_1 but the positions of Back L, Back R and Side L, Side R
 // speakers are different in these two definitions.
@@ skipping 24 matching lines @@
 }
 
 // static
 AUDCLNT_SHAREMODE WASAPIAudioOutputStream::GetShareMode() {
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kEnableExclusiveAudio))
     return AUDCLNT_SHAREMODE_EXCLUSIVE;
   return AUDCLNT_SHAREMODE_SHARED;
 }
 
+// static
+int WASAPIAudioOutputStream::HardwareChannelCount() {
+  ScopedComPtr<IAudioClient> client;

[DaleCurtis, 2013/01/31 02:34:33]

This section of code (115-124) is repeated pretty frequently. How about having a
method which just returns a WAVEFORMATPCMEX structure?

[tommi (sloooow) - chröme, 2013/01/31 13:42:08]

+1

[henrika (OOO until Aug 14), 2013/01/31 14:29:38]

Done. Much less overhead now. Thanks.

+  client = CoreAudioUtil::CreateDefaultClient(eRender, eConsole);
+  if (!client)
+    return 0;
+
+  WAVEFORMATPCMEX format;
+  HRESULT hr = CoreAudioUtil::GetSharedModeMixFormat(client, &format);
+  if (FAILED(hr))
+    return 0;
+
+  // Number of channels in the stream. Corresponds to the number of bits
+  // set in the dwChannelMask.
+  DVLOG(2) << "nChannels: " << format.Format.nChannels;
+  return static_cast<int>(format.Format.nChannels);
+}
+
+// static
+ChannelLayout WASAPIAudioOutputStream::HardwareChannelLayout() {
+  return ChannelConfigToChannelLayout(GetChannelConfig());
+}
+
+// static
+int WASAPIAudioOutputStream::HardwareSampleRate(ERole device_role) {
+  ScopedComPtr<IAudioClient> client;
+  client = CoreAudioUtil::CreateDefaultClient(eRender, device_role);
+  if (!client)
+    return 0;
+
+  WAVEFORMATPCMEX format;
+  HRESULT hr = CoreAudioUtil::GetSharedModeMixFormat(client, &format);
+  if (FAILED(hr))
+    return 0;
+
+  DVLOG(2) << "nSamplesPerSec: " << format.Format.nSamplesPerSec;
+  return static_cast<int>(format.Format.nSamplesPerSec);
+}
+
 WASAPIAudioOutputStream::WASAPIAudioOutputStream(AudioManagerWin* manager,
                                                  const AudioParameters& params,
                                                  ERole device_role)
     : creating_thread_id_(base::PlatformThread::CurrentId()),
       manager_(manager),
       opened_(false),
-      restart_rendering_mode_(false),
+      audio_parmeters_are_valid_(false),
       volume_(1.0),
       endpoint_buffer_size_frames_(0),
       device_role_(device_role),
       share_mode_(GetShareMode()),
-      client_channel_count_(params.channels()),
       num_written_frames_(0),
       source_(NULL),
       audio_bus_(AudioBus::Create(params)) {
   DCHECK(manager_);
+  DVLOG(1) << "WASAPIAudioOutputStream::WASAPIAudioOutputStream()";
+  DVLOG_IF(1, share_mode_ == AUDCLNT_SHAREMODE_EXCLUSIVE)
+      << "Core Audio (WASAPI) EXCLUSIVE MODE is enabled.";
+
+  if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
+    // Verify that the input audio parameters are identical (bit depth is
+    // excluded) to the preferred (native) audio parameters. Open() will fail
+    // if this is not the case.
+    AudioParameters preferred_params;
+    HRESULT hr = CoreAudioUtil::GetPreferredAudioParameters(
+        eRender, device_role, &preferred_params);
+    audio_parmeters_are_valid_ =
+        (SUCCEEDED(hr) && CompareAudioParameters(params, preferred_params));

[DaleCurtis, 2013/01/31 02:34:33]

extraneous parenthesis.

[henrika (OOO until Aug 14), 2013/01/31 14:29:38]

Done.

+    DLOG_IF(WARNING, !audio_parmeters_are_valid_)
+        << "Input and preferred parameters are not identical.";
+  }
 
   // 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";
 
-  if (share_mode_ == AUDCLNT_SHAREMODE_EXCLUSIVE) {
-    VLOG(1) << ">> Note that EXCLUSIVE MODE is enabled <<";
-  }
-
   // Set up the desired render format specified by the client. We use the
   // WAVE_FORMAT_EXTENSIBLE structure to ensure that multiple channel ordering
   // and high precision data can be supported.
 
   // Begin with the WAVEFORMATEX structure that specifies the basic format.
   WAVEFORMATEX* format = &format_.Format;
   format->wFormatTag = WAVE_FORMAT_EXTENSIBLE;
-  format->nChannels = client_channel_count_;
+  format->nChannels = params.channels();
   format->nSamplesPerSec = params.sample_rate();
   format->wBitsPerSample = params.bits_per_sample();
   format->nBlockAlign = (format->wBitsPerSample / 8) * format->nChannels;
   format->nAvgBytesPerSec = format->nSamplesPerSec * format->nBlockAlign;
   format->cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
 
   // Add the parts which are unique to WAVE_FORMAT_EXTENSIBLE.
   format_.Samples.wValidBitsPerSample = params.bits_per_sample();
   format_.dwChannelMask = GetChannelConfig();
   format_.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 
-  // Size in bytes of each audio frame.
-  frame_size_ = format->nBlockAlign;
-
   // 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.GetBytesPerBuffer() / format->nBlockAlign;
+  packet_size_frames_ = params.frames_per_buffer();
   packet_size_bytes_ = params.GetBytesPerBuffer();
   packet_size_ms_ = (1000.0 * packet_size_frames_) / params.sample_rate();
-  DVLOG(1) << "Number of bytes per audio frame  : " << frame_size_;
+  DVLOG(1) << "Number of bytes per audio frame  : " << format->nBlockAlign;
   DVLOG(1) << "Number of audio frames per packet: " << packet_size_frames_;
   DVLOG(1) << "Number of bytes per packet       : " << packet_size_bytes_;
   DVLOG(1) << "Number of milliseconds per packet: " << packet_size_ms_;
 
   // 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));
   DCHECK(stop_render_event_.IsValid());
 }
 
 WASAPIAudioOutputStream::~WASAPIAudioOutputStream() {}
 
 bool WASAPIAudioOutputStream::Open() {
+  DVLOG(1) << "WASAPIAudioOutputStream::Open()";
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
   if (opened_)
     return true;
 
-  // Channel mixing is not supported, it must be handled by ChannelMixer.
-  if (format_.Format.nChannels != client_channel_count_) {
-    LOG(ERROR) << "Channel down-mixing is not supported.";
+
+  // Audio parameters must be identical to the preferred set of parameters
+  // if shared mode (default) is utilized.
+  if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
+    if (!audio_parmeters_are_valid_) {
+      LOG(ERROR) << "Audio parameters are not valid.";
+      return false;
+    }
+  }
+
+  // Create an IAudioClient interface for the default rendering IMMDevice.
+  ScopedComPtr<IAudioClient> audio_client =
+      CoreAudioUtil::CreateDefaultClient(eRender, device_role_);
+  if (!audio_client)
+    return false;
+
+  // Extra sanity to ensure that the provided device format is still valid.
+  if (!CoreAudioUtil::IsFormatSupported(audio_client,

[DaleCurtis, 2013/01/31 02:34:33]

Won't it just return false anyways a little further down?

[henrika (OOO until Aug 14), 2013/01/31 14:29:38]

yes but we also get a nice summary (using DLOG) about what the closest set of
parameters that works is. I.e. we can see better what went wrong.

+                                        share_mode_,
+                                        &format_)) {
     return false;
   }
 
-  // Create an IMMDeviceEnumerator interface and obtain a reference to
-  // the IMMDevice interface of the default rendering device with the
-  // specified role.
-  HRESULT hr = SetRenderDevice();
-  if (FAILED(hr)) {
-    return false;
+  HRESULT hr = S_FALSE;
+  if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
+    // Initialize the audio stream between the client and the device in shared
+    // mode and using event-driven buffer handling.
+    hr = CoreAudioUtil::SharedModeInitialize(
+        audio_client, &format_, audio_samples_render_event_.Get(),
+        &endpoint_buffer_size_frames_);
+    if (FAILED(hr))
+      return false;
+
+    // We know from experience that the best possible callback sequence is
+    // achieved when the packet size (given by the native device period)
+    // is an even multiple of the endpoint buffer size.
+    // Examples: 48kHz => 960 % 480, 44.1kHz => 896 % 448 or 882 % 441.
+    if (endpoint_buffer_size_frames_ % packet_size_frames_ != 0) {
+      DLOG(ERROR) << "Bailing out due to non-perfect timing.";
+      return false;
+    }
+  } else {
+    // TODO(henrika): break out to CoreAudioUtil::ExclusiveModeInitialize()
+    // when removing the enable-exclusive-audio flag.
+    hr = ExclusiveModeInitialization(audio_client,
+                                     audio_samples_render_event_.Get(),
+                                     &endpoint_buffer_size_frames_);
+    if (FAILED(hr))
+      return false;
+
+    // The buffer scheme for exclusive mode streams is not designed for max
+    // flexibility. We only allow a "perfect match" between the packet size set
+    // by the user and the actual endpoint buffer size.
+    if (endpoint_buffer_size_frames_ != packet_size_frames_) {
+      DLOG(ERROR) << "Bailing out due to non-perfect timing.";
+      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 = ActivateRenderDevice();
-  if (FAILED(hr)) {
+  // Create an IAudioRenderClient client for an initialized IAudioClient.
+  // The IAudioRenderClient interface enables us to write output data to
+  // a rendering endpoint buffer.
+  ScopedComPtr<IAudioRenderClient> audio_render_client =
+      CoreAudioUtil::CreateRenderClient(audio_client);
+  if (!audio_render_client)
     return false;
-  }
 
-  // Verify that the selected audio endpoint supports the specified format
-  // set during construction.
-  // In exclusive mode, the client can choose to open the stream in any audio
-  // format that the endpoint device supports. In shared mode, the client must
-  // open the stream in the mix format that is currently in use by the audio
-  // engine (or a format that is similar to the mix format). The audio engine's
-  // input streams and the output mix from the engine are all in this format.
-  if (!DesiredFormatIsSupported()) {
-    return false;
-  }
-
-  // Initialize the audio stream between the client and the device using
-  // shared or exclusive mode and a lowest possible glitch-free latency.
-  // We will enter different code paths depending on the specified share mode.
-  hr = InitializeAudioEngine();
-  if (FAILED(hr)) {
-    return false;
-  }
+   // Store valid COM interfaces.
+  audio_client_ = audio_client;
+  audio_render_client_ = audio_render_client;
 
   opened_ = true;
   return true;
 }
 
 void WASAPIAudioOutputStream::Start(AudioSourceCallback* callback) {
+  DVLOG(1) << "WASAPIAudioOutputStream::Start()";
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
   CHECK(callback);
   CHECK(opened_);
 
   if (render_thread_.get()) {
     CHECK_EQ(callback, source_);
     return;
   }
 
-  if (restart_rendering_mode_) {
-    // The selected audio device has been removed or disabled and a new
-    // default device has been enabled instead. The current implementation
-    // does not to support this sequence of events. Given that Open()
-    // and Start() are usually called in one sequence; it should be a very
-    // rare event.
-    // TODO(henrika): it is possible to extend the functionality here.
-    LOG(ERROR) << "Unable to start since the selected default device has "
-                  "changed since Open() was called.";
-    return;
-  }
-
   source_ = callback;
 
-  // Avoid start-up glitches by filling up the endpoint buffer with "silence"
-  // before starting the stream.
-  BYTE* data_ptr = NULL;
-  HRESULT hr = audio_render_client_->GetBuffer(endpoint_buffer_size_frames_,
-                                               &data_ptr);
-  if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to use rendering audio buffer: " << std::hex << hr;
-    return;
-  }
-
-  // Using the AUDCLNT_BUFFERFLAGS_SILENT flag eliminates the need to
-  // explicitly write silence data to the rendering buffer.
-  audio_render_client_->ReleaseBuffer(endpoint_buffer_size_frames_,
-                                      AUDCLNT_BUFFERFLAGS_SILENT);
-  num_written_frames_ = endpoint_buffer_size_frames_;
-
-  // Sanity check: verify that the endpoint buffer is filled with silence.
-  UINT32 num_queued_frames = 0;
-  audio_client_->GetCurrentPadding(&num_queued_frames);
-  DCHECK(num_queued_frames == num_written_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()) {
+    DLOG(ERROR) << "Failed to start WASAPI render thread.";
+    return;
+  }
+
+  // Ensure that the endpoint buffer is prepared with silence.
+  UINT32 num_filled_frames = 0;
+  if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
+    if (!FillEndpointBufferWithSilence(&num_filled_frames)) {
+      DLOG(WARNING) << "Failed to prepare endpoint buffers with silence.";
+      return;
+    }
+    DCHECK_EQ(num_filled_frames, endpoint_buffer_size_frames_);
+  }
+  num_written_frames_ = num_filled_frames;
 
   // Start streaming data between the endpoint buffer and the audio engine.
-  hr = audio_client_->Start();
+  HRESULT hr = audio_client_->Start();
   if (FAILED(hr)) {
     SetEvent(stop_render_event_.Get());
     render_thread_->Join();
     render_thread_.reset();
     HandleError(hr);
   }
 }
 
 void WASAPIAudioOutputStream::Stop() {
+  DVLOG(1) << "WASAPIAudioOutputStream::Stop()";
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
   if (!render_thread_.get())
     return;
 
   // Stop output audio streaming.
   HRESULT hr = audio_client_->Stop();
   if (FAILED(hr)) {
     DLOG_IF(ERROR, hr != AUDCLNT_E_NOT_INITIALIZED)
         << "Failed to stop output streaming: " << std::hex << hr;
   }
@@ skipping 22 matching lines @@
   // would fail with AUDCLNT_E_BUFFER_ERROR at IAudioRenderClient::GetBuffer().
   // This check is is only needed for shared-mode streams.
   if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
     UINT32 num_queued_frames = 0;
     audio_client_->GetCurrentPadding(&num_queued_frames);
     DCHECK_EQ(0u, num_queued_frames);
   }
 }
 
 void WASAPIAudioOutputStream::Close() {
+  DVLOG(1) << "WASAPIAudioOutputStream::Close()";
   DCHECK_EQ(GetCurrentThreadId(), creating_thread_id_);
 
   // It is valid to call Close() before calling open or Start().
   // It is also valid to call Close() after Start() has been called.
   Stop();
 
   // Inform the audio manager that we have been closed. This will cause our
   // destruction.
   manager_->ReleaseOutputStream(this);
 }
 
 void WASAPIAudioOutputStream::SetVolume(double volume) {
   DVLOG(1) << "SetVolume(volume=" << volume << ")";
   float volume_float = static_cast<float>(volume);
   if (volume_float < 0.0f || volume_float > 1.0f) {
     return;
   }
   volume_ = volume_float;
 }
 
 void WASAPIAudioOutputStream::GetVolume(double* volume) {
   DVLOG(1) << "GetVolume()";
   *volume = static_cast<double>(volume_);
 }
 
-// static
-int WASAPIAudioOutputStream::HardwareChannelCount() {
-  // Use a WAVEFORMATEXTENSIBLE structure since it can specify both the
-  // number of channels and the mapping of channels to speakers for
-  // multichannel devices.
-  base::win::ScopedCoMem<WAVEFORMATPCMEX> format_ex;
-  HRESULT hr = GetMixFormat(
-      eConsole, reinterpret_cast<WAVEFORMATEX**>(&format_ex));
-  if (FAILED(hr))
-    return 0;
-
-  // Number of channels in the stream. Corresponds to the number of bits
-  // set in the dwChannelMask.
-  DVLOG(1) << "endpoint channels (out): " << format_ex->Format.nChannels;
-
-  return static_cast<int>(format_ex->Format.nChannels);
-}
-
-// static
-ChannelLayout WASAPIAudioOutputStream::HardwareChannelLayout() {
-  return ChannelConfigToChannelLayout(GetChannelConfig());
-}
-
-// static
-int WASAPIAudioOutputStream::HardwareSampleRate(ERole device_role) {
-  base::win::ScopedCoMem<WAVEFORMATEX> format;
-  HRESULT hr = GetMixFormat(device_role, &format);
-  if (FAILED(hr))
-    return 0;
-
-  DVLOG(2) << "nSamplesPerSec: " << format->nSamplesPerSec;
-  return static_cast<int>(format->nSamplesPerSec);
-}
-
 void WASAPIAudioOutputStream::Run() {
   ScopedCOMInitializer com_init(ScopedCOMInitializer::kMTA);
 
   // Increase the thread priority.
   render_thread_->SetThreadPriority(base::kThreadPriority_RealtimeAudio);
 
   // 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",
@@ skipping 39 matching lines @@
                                                FALSE,
                                                INFINITE);
 
     switch (wait_result) {
       case WAIT_OBJECT_0 + 0:
         // |stop_render_event_| has been set.
         playing = false;
         break;
       case WAIT_OBJECT_0 + 1:
         {
+          TRACE_EVENT0("audio", "WASAPIAudioOutputStream::Run");
+
           // |audio_samples_render_event_| has been set.
           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;
 
           if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
             // Get the padding value which represents the amount of rendering
             // data that is queued up to play in the endpoint buffer.
             hr = audio_client_->GetCurrentPadding(&num_queued_frames);
             num_available_frames =
                 endpoint_buffer_size_frames_ - num_queued_frames;
           } else {
             // While the stream is running, the system alternately sends one
             // buffer or the other to the client. This form of double buffering
             // is referred to as "ping-ponging". Each time the client receives
             // a buffer from the system (triggers this event) the client must
             // process the entire buffer. Calls to the GetCurrentPadding method
             // are unnecessary because the packet size must always equal the
             // buffer size. In contrast to the shared mode buffering scheme,
             // the latency for an event-driven, exclusive-mode stream depends
             // directly on the buffer size.
             num_available_frames = endpoint_buffer_size_frames_;
           }
+          if (FAILED(hr)) {
+            DLOG(ERROR) << "Failed to retrieve amount of available space: "
+                        << std::hex << hr;
+            continue;
+          }
 
-          // Check if there is enough available space to fit the packet size
-          // specified by the client.
-          if (FAILED(hr) || (num_available_frames < packet_size_frames_))
+          // It is my current assumption that we will always end up with a
+          // perfect match here where the packet size is identical to what
+          // the audio engine needs (num_available_frames). I am adding a
+          // DLOG to be able to track down any deviations from this theory.
+          if ((num_available_frames > 0) &&
+              (num_available_frames != packet_size_frames_)) {
+            DLOG(WARNING) << "Non-perfect timing case detected.";
             continue;
+          }
 
-          // Derive the number of packets we need get from the client to
-          // fill up the available area in the endpoint buffer.
-          // |num_packets| will always be one for exclusive-mode streams.
-          size_t num_packets = (num_available_frames / packet_size_frames_);
+          // Grab all available space in the rendering endpoint buffer
+          // into which the client can write a data packet.
+          hr = audio_render_client_->GetBuffer(packet_size_frames_,
+                                               &audio_data);
+          if (FAILED(hr)) {
+            DLOG(ERROR) << "Failed to use rendering audio buffer: "
+                        << std::hex << hr;
+            continue;
+          }
 
-          // Get data from the client/source.
-          for (size_t n = 0; n < num_packets; ++n) {
-            // Grab all available space in the rendering endpoint buffer
-            // into which the client can write a data packet.
-            hr = audio_render_client_->GetBuffer(packet_size_frames_,
-                                                 &audio_data);
-            if (FAILED(hr)) {
-              DLOG(ERROR) << "Failed to use rendering audio buffer: "
-                          << std::hex << hr;
-              continue;
-            }
+          // 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);
+          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);
 
-            // 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);
-            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 =
+                num_written_frames_ + packet_size_frames_;
 
-              // 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 =
-                  num_written_frames_ + packet_size_frames_;
+            // Derive the actual delay value which will be fed to the
+            // render client using the OnMoreData() callback.
+            audio_delay_bytes = (pos_last_sample_written_frames -
+                pos_sample_playing_frames) *  format_.Format.nBlockAlign;
+          }
 
-              // Derive the actual delay value which will be fed to the
-              // render client using the OnMoreData() callback.
-              audio_delay_bytes = (pos_last_sample_written_frames -
-                  pos_sample_playing_frames) *  frame_size_;
-            }
+          // Read a data packet from the registered client source and
+          // deliver a delay estimate in the same callback to the client.
+          // A time stamp is also stored in the AudioBuffersState. This
+          // time stamp can be used at the client side to compensate for
+          // the delay between the usage of the delay value and the time
+          // of generation.
 
-            // Read a data packet from the registered client source and
-            // deliver a delay estimate in the same callback to the client.
-            // A time stamp is also stored in the AudioBuffersState. This
-            // time stamp can be used at the client side to compensate for
-            // the delay between the usage of the delay value and the time
-            // of generation.
+          uint32 num_filled_bytes = 0;
+          const int bytes_per_sample = format_.Format.wBitsPerSample >> 3;
 
-            uint32 num_filled_bytes = 0;
-            const int bytes_per_sample = format_.Format.wBitsPerSample >> 3;
+          int frames_filled = source_->OnMoreData(
+              audio_bus_.get(), AudioBuffersState(0, audio_delay_bytes));
+          num_filled_bytes = frames_filled * format_.Format.nBlockAlign;
+          DCHECK_LE(num_filled_bytes, packet_size_bytes_);
 
-            int frames_filled = source_->OnMoreData(
-                audio_bus_.get(), AudioBuffersState(0, audio_delay_bytes));
-            num_filled_bytes = frames_filled * frame_size_;
-            DCHECK_LE(num_filled_bytes, packet_size_bytes_);
-            // Note: If this ever changes to output raw float the data must be
-            // clipped and sanitized since it may come from an untrusted
-            // source such as NaCl.
-            audio_bus_->ToInterleaved(
-                frames_filled, bytes_per_sample, audio_data);
+          // Note: If this ever changes to output raw float the data must be
+          // clipped and sanitized since it may come from an untrusted
+          // source such as NaCl.
+          audio_bus_->ToInterleaved(
+              frames_filled, bytes_per_sample, audio_data);
 
-            // Perform in-place, software-volume adjustments.
-            media::AdjustVolume(audio_data,
-                                num_filled_bytes,
-                                audio_bus_->channels(),
-                                bytes_per_sample,
-                                volume_);
+          // Perform in-place, software-volume adjustments.
+          media::AdjustVolume(audio_data,
+                              num_filled_bytes,
+                              audio_bus_->channels(),
+                              bytes_per_sample,
+                              volume_);
 
-            // Zero out the part of the packet which has not been filled by
-            // the client. Using silence is the least bad option in this
-            // situation.
-            if (num_filled_bytes < packet_size_bytes_) {
-              memset(&audio_data[num_filled_bytes], 0,
-                     (packet_size_bytes_ - num_filled_bytes));
-            }
+          // Zero out the part of the packet which has not been filled by
+          // the client. Using silence is the least bad option in this
+          // situation.
+          if (num_filled_bytes < packet_size_bytes_) {
+            memset(&audio_data[num_filled_bytes], 0,
+                   (packet_size_bytes_ - num_filled_bytes));
+          }
 
-            // Release the buffer space acquired in the GetBuffer() call.
-            DWORD flags = 0;
-            audio_render_client_->ReleaseBuffer(packet_size_frames_,
-                                                flags);
+          // Release the buffer space acquired in the GetBuffer() call.
+          DWORD flags = 0;
+          audio_render_client_->ReleaseBuffer(packet_size_frames_,
+                                              flags);
 
-            num_written_frames_ += packet_size_frames_;
-          }
+          num_written_frames_ += packet_size_frames_;
         }
         break;
       default:
         error = true;
         break;
     }
   }
 
   if (playing && error) {
     // Stop audio rendering since something has gone wrong in our main thread
@@ skipping 10 matching lines @@
 }
 
 void WASAPIAudioOutputStream::HandleError(HRESULT err) {
   CHECK((started() && GetCurrentThreadId() == render_thread_->tid()) ||
         (!started() && GetCurrentThreadId() == creating_thread_id_));
   NOTREACHED() << "Error code: " << std::hex << err;
   if (source_)
     source_->OnError(this, static_cast<int>(err));
 }
 
-HRESULT WASAPIAudioOutputStream::SetRenderDevice() {
-  ScopedComPtr<IMMDeviceEnumerator> device_enumerator;
-  ScopedComPtr<IMMDevice> endpoint_device;
-
-  // Create the IMMDeviceEnumerator interface.
-  HRESULT hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
-                                NULL,
-                                CLSCTX_INPROC_SERVER,
-                                __uuidof(IMMDeviceEnumerator),
-                                device_enumerator.ReceiveVoid());
-  if (SUCCEEDED(hr)) {
-    // Retrieve the default render 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 = device_enumerator->GetDefaultAudioEndpoint(
-        eRender, device_role_, endpoint_device.Receive());
-    if (FAILED(hr))
-      return hr;
-
-    // Verify that the audio endpoint device is active. That is, 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 render device is not active.";
-        hr = E_ACCESSDENIED;
-      }
-    }
-  }
-
-  if (SUCCEEDED(hr)) {
-    device_enumerator_ = device_enumerator;
-    endpoint_device_ = endpoint_device;
-  }
-
-  return hr;
-}
-
-HRESULT WASAPIAudioOutputStream::ActivateRenderDevice() {
-  ScopedComPtr<IAudioClient> audio_client;
-
-  // Creates and activates an IAudioClient COM object given the selected
-  // render endpoint device.
-  HRESULT hr = endpoint_device_->Activate(__uuidof(IAudioClient),
-                                          CLSCTX_INPROC_SERVER,
-                                          NULL,
-                                          audio_client.ReceiveVoid());
-  if (SUCCEEDED(hr)) {
-    // Retrieve the stream format that the audio engine uses for its internal
-    // processing/mixing of shared-mode streams.
-    audio_engine_mix_format_.Reset(NULL);
-    hr = audio_client->GetMixFormat(
-        reinterpret_cast<WAVEFORMATEX**>(&audio_engine_mix_format_));
-
-    if (SUCCEEDED(hr)) {
-      audio_client_ = audio_client;
-    }
-  }
-
-  return hr;
-}
-
-bool WASAPIAudioOutputStream::DesiredFormatIsSupported() {
-  // Determine, before calling IAudioClient::Initialize(), whether the audio
-  // engine supports a particular stream format.
-  // In shared mode, the audio engine always supports the mix format,
-  // which is stored in the |audio_engine_mix_format_| member and it is also
-  // possible to receive a proposed (closest) format if the current format is
-  // not supported.
-  base::win::ScopedCoMem<WAVEFORMATEXTENSIBLE> closest_match;
-  HRESULT hr = audio_client_->IsFormatSupported(
-      share_mode_, reinterpret_cast<WAVEFORMATEX*>(&format_),
-      reinterpret_cast<WAVEFORMATEX**>(&closest_match));
-
-  // This log can only be triggered for shared mode.
-  DLOG_IF(ERROR, hr == S_FALSE) << "Format is not supported "
-                                << "but a closest match exists.";
-  // This log can be triggered both for shared and exclusive modes.
-  DLOG_IF(ERROR, hr == AUDCLNT_E_UNSUPPORTED_FORMAT) << "Unsupported format.";
-  if (hr == S_FALSE) {
-    DVLOG(1) << "wFormatTag    : " << closest_match->Format.wFormatTag;
-    DVLOG(1) << "nChannels     : " << closest_match->Format.nChannels;
-    DVLOG(1) << "nSamplesPerSec: " << closest_match->Format.nSamplesPerSec;
-    DVLOG(1) << "wBitsPerSample: " << closest_match->Format.wBitsPerSample;
-  }
-
-  return (hr == S_OK);
-}
-
-HRESULT WASAPIAudioOutputStream::InitializeAudioEngine() {
-#if !defined(NDEBUG)
-  // The period between processing passes by the audio engine is fixed for a
-  // particular audio endpoint device and represents the smallest processing
-  // quantum for the audio engine. This period plus the stream latency between
-  // the buffer and endpoint device represents the minimum possible latency
-  // that an audio application can achieve in shared mode.
-  {
-    REFERENCE_TIME default_device_period = 0;
-    REFERENCE_TIME minimum_device_period = 0;
-    HRESULT hr_dbg = audio_client_->GetDevicePeriod(&default_device_period,
-      &minimum_device_period);
-    if (SUCCEEDED(hr_dbg)) {
-      // Shared mode device period.
-      DVLOG(1) << "shared mode (default) device period: "
-               << static_cast<double>(default_device_period / 10000.0)
-               << " [ms]";
-      // Exclusive mode device period.
-      DVLOG(1) << "exclusive mode (minimum) device period: "
-               << static_cast<double>(minimum_device_period / 10000.0)
-               << " [ms]";
-    }
-
-    REFERENCE_TIME latency = 0;
-    hr_dbg = audio_client_->GetStreamLatency(&latency);
-    if (SUCCEEDED(hr_dbg)) {
-      DVLOG(1) << "stream latency: " << static_cast<double>(latency / 10000.0)
-               << " [ms]";
-    }
-  }
-#endif
-
-  HRESULT hr = S_FALSE;
-
-  // Perform different initialization depending on if the device shall be
-  // opened in shared mode or in exclusive mode.
-  hr = (share_mode_ == AUDCLNT_SHAREMODE_SHARED) ?
-      SharedModeInitialization() : ExclusiveModeInitialization();
-  if (FAILED(hr)) {
-    LOG(WARNING) << "IAudioClient::Initialize() failed: " << std::hex << hr;
-    return hr;
-  }
-
-  // Retrieve the length of the endpoint buffer. The buffer length represents
-  // the maximum amount of rendering data that the client can write to
-  // 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;
-  DVLOG(1) << "endpoint buffer size: " << endpoint_buffer_size_frames_
-           << " [frames]";
-
-  // The buffer scheme for exclusive mode streams is not designed for max
-  // flexibility. We only allow a "perfect match" between the packet size set
-  // by the user and the actual endpoint buffer size.
-  if (share_mode_ == AUDCLNT_SHAREMODE_EXCLUSIVE &&
-      endpoint_buffer_size_frames_ != packet_size_frames_) {
-    hr = AUDCLNT_E_INVALID_SIZE;
-    DLOG(ERROR) << "AUDCLNT_E_INVALID_SIZE";
-    return hr;
-  }
-
-  // Set the event handle that the audio engine will signal each time
-  // a buffer becomes ready to be processed by the client.
-  hr = audio_client_->SetEventHandle(audio_samples_render_event_.Get());
-  if (FAILED(hr))
-    return hr;
-
-  // Get access to the IAudioRenderClient interface. This interface
-  // enables us to write output data to a rendering endpoint buffer.
-  // The methods in this interface manage the movement of data packets
-  // that contain audio-rendering data.
-  hr = audio_client_->GetService(__uuidof(IAudioRenderClient),
-                                 audio_render_client_.ReceiveVoid());
-  return hr;
-}
-
-HRESULT WASAPIAudioOutputStream::SharedModeInitialization() {
-  DCHECK_EQ(share_mode_, AUDCLNT_SHAREMODE_SHARED);
-
-  // TODO(henrika): this buffer scheme is still under development.
-  // The exact details are yet to be determined based on tests with different
-  // audio clients.
-  int glitch_free_buffer_size_ms = static_cast<int>(packet_size_ms_ + 0.5);
-  if (audio_engine_mix_format_->Format.nSamplesPerSec % 8000 == 0) {
-    // Initial tests have shown that we have to add 10 ms extra to
-    // ensure that we don't run empty for any packet size.
-    glitch_free_buffer_size_ms += 10;
-  } else if (audio_engine_mix_format_->Format.nSamplesPerSec % 11025 == 0) {
-    // Initial tests have shown that we have to add 20 ms extra to
-    // ensure that we don't run empty for any packet size.
-    glitch_free_buffer_size_ms += 20;
-  } else {
-    DLOG(WARNING) << "Unsupported sample rate "
-        << audio_engine_mix_format_->Format.nSamplesPerSec << " detected";
-    glitch_free_buffer_size_ms += 20;
-  }
-  DVLOG(1) << "glitch_free_buffer_size_ms: " << glitch_free_buffer_size_ms;
-  REFERENCE_TIME requested_buffer_duration =
-      static_cast<REFERENCE_TIME>(glitch_free_buffer_size_ms * 10000);
-
-  // Initialize the audio stream between the client and the device.
-  // We connect indirectly through the audio engine by using shared mode
-  // and WASAPI is initialized in an event driven mode.
-  // Note that this API ensures that the buffer is never smaller than the
-  // minimum buffer size needed to ensure glitch-free rendering.
-  // If we requests a buffer size that is smaller than the audio engine's
-  // minimum required buffer size, the method sets the buffer size to this
-  // minimum buffer size rather than to the buffer size requested.
-  HRESULT hr = S_FALSE;
-  hr = audio_client_->Initialize(AUDCLNT_SHAREMODE_SHARED,
-                                 AUDCLNT_STREAMFLAGS_EVENTCALLBACK |
-                                 AUDCLNT_STREAMFLAGS_NOPERSIST,
-                                 requested_buffer_duration,
-                                 0,
-                                 reinterpret_cast<WAVEFORMATEX*>(&format_),
-                                 NULL);
-  return hr;
-}
-
-HRESULT WASAPIAudioOutputStream::ExclusiveModeInitialization() {
+HRESULT WASAPIAudioOutputStream::ExclusiveModeInitialization(
+    IAudioClient* client, HANDLE event_handle, size_t* endpoint_buffer_size) {
   DCHECK_EQ(share_mode_, AUDCLNT_SHAREMODE_EXCLUSIVE);
 
   float f = (1000.0 * packet_size_frames_) / format_.Format.nSamplesPerSec;
   REFERENCE_TIME requested_buffer_duration =
       static_cast<REFERENCE_TIME>(f * 10000.0 + 0.5);
 
+  DWORD stream_flags = AUDCLNT_STREAMFLAGS_NOPERSIST;
+  bool use_event = (event_handle != NULL &&
+                    event_handle != INVALID_HANDLE_VALUE);
+  if (use_event)
+    stream_flags |= AUDCLNT_STREAMFLAGS_EVENTCALLBACK;
+  DVLOG(2) << "stream_flags: 0x" << std::hex << stream_flags;
+
   // Initialize the audio stream between the client and the device.
   // For an exclusive-mode stream that uses event-driven buffering, the
   // caller must specify nonzero values for hnsPeriodicity and
   // hnsBufferDuration, and the values of these two parameters must be equal.
   // The Initialize method allocates two buffers for the stream. Each buffer
   // is equal in duration to the value of the hnsBufferDuration parameter.
   // Following the Initialize call for a rendering stream, the caller should
   // fill the first of the two buffers before starting the stream.
   HRESULT hr = S_FALSE;
-  hr = audio_client_->Initialize(AUDCLNT_SHAREMODE_EXCLUSIVE,
-                                 AUDCLNT_STREAMFLAGS_EVENTCALLBACK |
-                                 AUDCLNT_STREAMFLAGS_NOPERSIST,
-                                 requested_buffer_duration,
-                                 requested_buffer_duration,
-                                 reinterpret_cast<WAVEFORMATEX*>(&format_),
-                                 NULL);
+  hr = client->Initialize(AUDCLNT_SHAREMODE_EXCLUSIVE,
+                          stream_flags,
+                          requested_buffer_duration,
+                          requested_buffer_duration,
+                          reinterpret_cast<WAVEFORMATEX*>(&format_),
+                          NULL);
   if (FAILED(hr)) {
     if (hr == AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED) {
       LOG(ERROR) << "AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED";
 
       UINT32 aligned_buffer_size = 0;
-      audio_client_->GetBufferSize(&aligned_buffer_size);
+      client->GetBufferSize(&aligned_buffer_size);
       DVLOG(1) << "Use aligned buffer size instead: " << aligned_buffer_size;
-      audio_client_.Release();
 
       // Calculate new aligned periodicity. Each unit of reference time
       // is 100 nanoseconds.
       REFERENCE_TIME aligned_buffer_duration = static_cast<REFERENCE_TIME>(
           (10000000.0 * aligned_buffer_size / format_.Format.nSamplesPerSec)
           + 0.5);
 
       // It is possible to re-activate and re-initialize the audio client
       // at this stage but we bail out with an error code instead and
       // combine it with a log message which informs about the suggested
       // aligned buffer size which should be used instead.
       DVLOG(1) << "aligned_buffer_duration: "
                 << static_cast<double>(aligned_buffer_duration / 10000.0)
                 << " [ms]";
     } else if (hr == AUDCLNT_E_INVALID_DEVICE_PERIOD) {
       // We will get this error if we try to use a smaller buffer size than
       // the minimum supported size (usually ~3ms on Windows 7).
       LOG(ERROR) << "AUDCLNT_E_INVALID_DEVICE_PERIOD";
     }
+    return hr;
   }
 
+  if (use_event) {
+    hr = client->SetEventHandle(event_handle);
+    if (FAILED(hr)) {
+      DVLOG(1) << "IAudioClient::SetEventHandle: " << std::hex << hr;
+      return hr;
+    }
+  }
+
+  UINT32 buffer_size_in_frames = 0;
+  hr = client->GetBufferSize(&buffer_size_in_frames);
+  if (FAILED(hr)) {
+    DVLOG(1) << "IAudioClient::GetBufferSize: " << std::hex << hr;
+    return hr;
+  }
+
+  *endpoint_buffer_size = static_cast<size_t>(buffer_size_in_frames);
+  DVLOG(2) << "endpoint buffer size: " << buffer_size_in_frames;
   return hr;
 }
 
-std::string WASAPIAudioOutputStream::GetDeviceName(LPCWSTR device_id) const {
-  std::string name;
-  ScopedComPtr<IMMDevice> audio_device;
+bool WASAPIAudioOutputStream::FillEndpointBufferWithSilence(
+  UINT32* num_written_frames) {
+  UINT32 num_queued_frames = 0;
+  HRESULT hr = audio_client_->GetCurrentPadding(&num_queued_frames);
+  if (FAILED(hr))
+    return false;
 
-  // Get the IMMDevice interface corresponding to the given endpoint ID string.
-  HRESULT hr = device_enumerator_->GetDevice(device_id, audio_device.Receive());
-  if (SUCCEEDED(hr)) {
-    // Retrieve user-friendly name of endpoint device.
-    // Example: "Speakers (Realtek High Definition Audio)".
-    ScopedComPtr<IPropertyStore> properties;
-    hr = audio_device->OpenPropertyStore(STGM_READ, properties.Receive());
-    if (SUCCEEDED(hr)) {
-      PROPVARIANT friendly_name;
-      PropVariantInit(&friendly_name);
-      hr = properties->GetValue(PKEY_Device_FriendlyName, &friendly_name);
-      if (SUCCEEDED(hr) && friendly_name.vt == VT_LPWSTR) {
-        if (friendly_name.pwszVal)
-          name = WideToUTF8(friendly_name.pwszVal);
-      }
-      PropVariantClear(&friendly_name);
-    }
-  }
-  return name;
+  BYTE* data = NULL;
+  int num_frames_to_fill = endpoint_buffer_size_frames_ - num_queued_frames;
+  hr = audio_render_client_->GetBuffer(num_frames_to_fill, &data);
+  if (FAILED(hr))
+    return false;
+
+  // Using the AUDCLNT_BUFFERFLAGS_SILENT flag eliminates the need to
+  // explicitly write silence data to the rendering buffer.
+  DVLOG(2) << "filling up " << num_frames_to_fill << " frames with silence";
+  hr = audio_render_client_->ReleaseBuffer(num_frames_to_fill,
+                                          AUDCLNT_BUFFERFLAGS_SILENT);
+  if (FAILED(hr))
+    return false;
+
+  // Get the amount of valid, unread data that the endpoint buffer
+  // currently contains. This amount corresponds to the number of written
+  // audio frames.
+  hr = audio_client_->GetCurrentPadding(&num_queued_frames);
+  if (FAILED(hr))
+    return false;
+  *num_written_frames = num_queued_frames;
+
+  return SUCCEEDED(hr);
 }
 
 }  // namespace media