Avoids irregular OnMoreData callbacks on Windows using Core Audio

media/audio/win/core_audio_util_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/core_audio_util_win.h"
 
 #include <Audioclient.h>
 #include <Functiondiscoverykeys_devpkey.h>
 
 #include "base/command_line.h"
@@ skipping 120 matching lines @@
 }
 
 AUDCLNT_SHAREMODE CoreAudioUtil::GetShareMode() {
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kEnableExclusiveAudio))
     return AUDCLNT_SHAREMODE_EXCLUSIVE;
   return AUDCLNT_SHAREMODE_SHARED;
 }
 
 int CoreAudioUtil::NumberOfActiveDevices(EDataFlow data_flow) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
   if (!device_enumerator)
     return 0;
 
   // Generate a collection of active (present and not disabled) audio endpoint
   // devices for the specified data-flow direction.
   // This method will succeed even if all devices are disabled.
   ScopedComPtr<IMMDeviceCollection> collection;
   HRESULT hr = device_enumerator->EnumAudioEndpoints(data_flow,
                                                      DEVICE_STATE_ACTIVE,
                                                      collection.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "IMMDeviceCollection::EnumAudioEndpoints: " << std::hex << hr;
     return 0;
   }
 
   // Retrieve the number of active audio devices for the specified direction
   UINT number_of_active_devices = 0;
   collection->GetCount(&number_of_active_devices);
   DVLOG(2) << ((data_flow == eCapture) ? "[in ] " : "[out] ")
            << "number of devices: " << number_of_active_devices;
   return static_cast<int>(number_of_active_devices);
 }
 
 ScopedComPtr<IMMDeviceEnumerator> CoreAudioUtil::CreateDeviceEnumerator() {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator;
   HRESULT hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
                                 NULL,
                                 CLSCTX_INPROC_SERVER,
                                 __uuidof(IMMDeviceEnumerator),
                                 device_enumerator.ReceiveVoid());
   // CO_E_NOTINITIALIZED is the most likely reason for failure and if that
   // happens we might as well die here.
   CHECK(SUCCEEDED(hr));
   return device_enumerator;
 }
 
 ScopedComPtr<IMMDevice> CoreAudioUtil::CreateDefaultDevice(EDataFlow data_flow,
                                                            ERole role) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> endpoint_device;
 
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
   if (!device_enumerator)
     return endpoint_device;
 
   // Retrieve the default audio endpoint for the specified data-flow
   // direction and role.
@@ skipping 14 matching lines @@
     if (!(state & DEVICE_STATE_ACTIVE)) {
       DVLOG(1) << "Selected endpoint device is not active";
       endpoint_device.Release();
     }
   }
   return endpoint_device;
 }
 
 ScopedComPtr<IMMDevice> CoreAudioUtil::CreateDevice(
     const std::string& device_id) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> endpoint_device;
 
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
   if (!device_enumerator)
     return endpoint_device;
 
   // Retrieve an audio device specified by an endpoint device-identification
   // string.
   HRESULT hr = device_enumerator->GetDevice(UTF8ToUTF16(device_id).c_str(),
                                             endpoint_device.Receive());
   DVLOG_IF(1, FAILED(hr)) << "IMMDeviceEnumerator::GetDevice: "
                           << std::hex << hr;
   return endpoint_device;
 }
 
 HRESULT CoreAudioUtil::GetDeviceName(IMMDevice* device, AudioDeviceName* name) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
 
   // Retrieve unique name of endpoint device.
   // Example: "{0.0.1.00000000}.{8db6020f-18e3-4f25-b6f5-7726c9122574}".
   AudioDeviceName device_name;
   ScopedCoMem<WCHAR> endpoint_device_id;
   HRESULT hr = device->GetId(&endpoint_device_id);
   if (FAILED(hr))
     return hr;
   WideToUTF8(endpoint_device_id, wcslen(endpoint_device_id),
              &device_name.unique_id);
@@ skipping 14 matching lines @@
                &device_name.device_name);
   }
 
   *name = device_name;
   DVLOG(2) << "friendly name: " << device_name.device_name;
   DVLOG(2) << "unique id    : " << device_name.unique_id;
   return hr;
 }
 
 std::string CoreAudioUtil::GetFriendlyName(const std::string& device_id) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> audio_device = CreateDevice(device_id);
   if (!audio_device)
     return std::string();
 
   AudioDeviceName device_name;
   HRESULT hr = GetDeviceName(audio_device, &device_name);
   if (FAILED(hr))
     return std::string();
 
   return device_name.device_name;
 }
 
 bool CoreAudioUtil::DeviceIsDefault(EDataFlow flow,
                                     ERole role,
                                     std::string device_id) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> device = CreateDefaultDevice(flow, role);
   if (!device)
     return false;
 
   ScopedCoMem<WCHAR> default_device_id;
   HRESULT hr = device->GetId(&default_device_id);
   if (FAILED(hr))
     return false;
 
   std::string str_default;
   WideToUTF8(default_device_id, wcslen(default_device_id), &str_default);
   if (device_id.compare(str_default) != 0)
     return false;
   return true;
 }
 
 EDataFlow CoreAudioUtil::GetDataFlow(IMMDevice* device) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
   ScopedComPtr<IMMEndpoint> endpoint;
   HRESULT hr = device->QueryInterface(endpoint.Receive());
   if (FAILED(hr)) {
     DVLOG(1) << "IMMDevice::QueryInterface: " << std::hex << hr;
     return eAll;
   }
 
   EDataFlow data_flow;
   hr = endpoint->GetDataFlow(&data_flow);
   if (FAILED(hr)) {
     DVLOG(1) << "IMMEndpoint::GetDataFlow: " << std::hex << hr;
     return eAll;
   }
   return data_flow;
 }
 
 ScopedComPtr<IAudioClient> CoreAudioUtil::CreateClient(
     IMMDevice* audio_device) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
 
   // Creates and activates an IAudioClient COM object given the selected
   // endpoint device.
   ScopedComPtr<IAudioClient> audio_client;
   HRESULT hr = audio_device->Activate(__uuidof(IAudioClient),
                                       CLSCTX_INPROC_SERVER,
                                       NULL,
                                       audio_client.ReceiveVoid());
   DVLOG_IF(1, FAILED(hr)) << "IMMDevice::Activate: " << std::hex << hr;
   return audio_client;
 }
 
 ScopedComPtr<IAudioClient> CoreAudioUtil::CreateDefaultClient(
     EDataFlow data_flow, ERole role) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> default_device(CreateDefaultDevice(data_flow, role));
   return (default_device ? CreateClient(default_device) :
       ScopedComPtr<IAudioClient>());
 }
 
 HRESULT CoreAudioUtil::GetSharedModeMixFormat(
     IAudioClient* client, WAVEFORMATPCMEX* format) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
   ScopedCoMem<WAVEFORMATPCMEX> format_pcmex;
   HRESULT hr = client->GetMixFormat(
       reinterpret_cast<WAVEFORMATEX**>(&format_pcmex));
   if (FAILED(hr))
     return hr;
 
   size_t bytes = sizeof(WAVEFORMATEX) + format_pcmex->Format.cbSize;
   DCHECK_EQ(bytes, sizeof(WAVEFORMATPCMEX));
 
   memcpy(format, format_pcmex, bytes);
 
   DVLOG(2) << "wFormatTag: 0x" << std::hex << format->Format.wFormatTag
            << ", nChannels: " << std::dec << format->Format.nChannels
            << ", nSamplesPerSec: " << format->Format.nSamplesPerSec
            << ", nAvgBytesPerSec: " << format->Format.nAvgBytesPerSec
            << ", nBlockAlign: " << format->Format.nBlockAlign
            << ", wBitsPerSample: " << format->Format.wBitsPerSample
            << ", cbSize: " << format->Format.cbSize
            << ", wValidBitsPerSample: " << format->Samples.wValidBitsPerSample
            << ", dwChannelMask: 0x" << std::hex << format->dwChannelMask;
 
   return hr;
 }
 
+HRESULT CoreAudioUtil::GetDefaultSharedModeMixFormat(
+  EDataFlow data_flow, ERole role, WAVEFORMATPCMEX* format) {

[tommi (sloooow) - chröme, 2013/01/31 16:18:24]

indent

[henrika (OOO until Aug 14), 2013/02/01 10:55:56]

Done.

+  DCHECK(IsSupported());
+  ScopedComPtr<IAudioClient> client;

[tommi (sloooow) - chröme, 2013/01/31 16:18:24]

pass CreateDefaultClient to the constructor

[henrika (OOO until Aug 14), 2013/02/01 10:55:56]

Done.

+  client = CreateDefaultClient(data_flow, role);
+  if (!client) {
+    // Map NULL-pointer to new error code which can be different from the
+    // actual error code. The exact value is not important here.
+    return AUDCLNT_E_ENDPOINT_CREATE_FAILED;
+  }
+  return CoreAudioUtil::GetSharedModeMixFormat(client, format);
+}
+
 bool CoreAudioUtil::IsFormatSupported(IAudioClient* client,
                                       AUDCLNT_SHAREMODE share_mode,
                                       const WAVEFORMATPCMEX* format) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
   ScopedCoMem<WAVEFORMATEXTENSIBLE> closest_match;
   HRESULT hr = client->IsFormatSupported(
       share_mode, reinterpret_cast<const 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(2) << "wFormatTag: " << closest_match->Format.wFormatTag
              << ", nChannels: " << closest_match->Format.nChannels
              << ", nSamplesPerSec: " << closest_match->Format.nSamplesPerSec
              << ", wBitsPerSample: " << closest_match->Format.wBitsPerSample;
   }
 
   return (hr == S_OK);
 }
 
 HRESULT CoreAudioUtil::GetDevicePeriod(IAudioClient* client,
                                        AUDCLNT_SHAREMODE share_mode,
                                        REFERENCE_TIME* device_period) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
 
   // Get the period of the engine thread.
   REFERENCE_TIME default_period = 0;
   REFERENCE_TIME minimum_period = 0;
   HRESULT hr = client->GetDevicePeriod(&default_period, &minimum_period);
   if (FAILED(hr))
     return hr;
 
   *device_period = (share_mode == AUDCLNT_SHAREMODE_SHARED) ? default_period :
       minimum_period;
   DVLOG(2) << "device_period: "
            << RefererenceTimeToTimeDelta(*device_period).InMillisecondsF()
            << " [ms]";
   return hr;
 }
 
 HRESULT CoreAudioUtil::GetPreferredAudioParameters(
     IAudioClient* client, AudioParameters* params) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
   WAVEFORMATPCMEX format;
   HRESULT hr = GetSharedModeMixFormat(client, &format);
   if (FAILED(hr))
     return hr;
 
   REFERENCE_TIME default_period = 0;
   hr = GetDevicePeriod(client, AUDCLNT_SHAREMODE_SHARED, &default_period);
   if (FAILED(hr))
     return hr;
 
@@ skipping 30 matching lines @@
                                sample_rate,
                                bits_per_sample,
                                frames_per_buffer);
 
   *params = audio_params;
   return hr;
 }
 
 HRESULT CoreAudioUtil::GetPreferredAudioParameters(
     EDataFlow data_flow, ERole role, AudioParameters* params) {
-  DCHECK(CoreAudioUtil::IsSupported());
-
+  DCHECK(IsSupported());
   ScopedComPtr<IAudioClient> client = CreateDefaultClient(data_flow, role);
   if (!client) {
     // Map NULL-pointer to new error code which can be different from the
     // actual error code. The exact value is not important here.
     return AUDCLNT_E_ENDPOINT_CREATE_FAILED;
   }
   return GetPreferredAudioParameters(client, params);
 }
 
 HRESULT CoreAudioUtil::SharedModeInitialize(IAudioClient* client,
                                             const WAVEFORMATPCMEX* format,
                                             HANDLE event_handle,
                                             size_t* endpoint_buffer_size) {
-  DCHECK(CoreAudioUtil::IsSupported());
-
+  DCHECK(IsSupported());
   DWORD stream_flags = AUDCLNT_STREAMFLAGS_NOPERSIST;
 
   // Enable event-driven streaming if a valid event handle is provided.
   // After the stream starts, the audio engine will signal the event handle
   // to notify the client each time a buffer becomes ready to process.
   // Event-driven buffering is supported for both rendering and capturing.
   // Both shared-mode and exclusive-mode streams can use event-driven buffering.
   bool use_event = (event_handle != NULL &&
                     event_handle != INVALID_HANDLE_VALUE);
   if (use_event)
@@ skipping 33 matching lines @@
   // TODO(henrika): utilize when delay measurements are added.
   REFERENCE_TIME  latency = 0;
   hr = client->GetStreamLatency(&latency);
   DVLOG(2) << "stream latency: "
            << RefererenceTimeToTimeDelta(latency).InMillisecondsF() << " [ms]";
   return hr;
 }
 
 ScopedComPtr<IAudioRenderClient> CoreAudioUtil::CreateRenderClient(
     IAudioClient* client) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
 
   // Get access to the IAudioRenderClient interface. This interface
   // enables us to write output data to a rendering endpoint buffer.
   ScopedComPtr<IAudioRenderClient> audio_render_client;
   HRESULT hr = client->GetService(__uuidof(IAudioRenderClient),
                                   audio_render_client.ReceiveVoid());
   if (FAILED(hr)) {
     DVLOG(1) << "IAudioClient::GetService: " << std::hex << hr;
     return ScopedComPtr<IAudioRenderClient>();
   }
-
-  // TODO(henrika): verify that this scheme is the same for shared mode and
-  // exclusive mode streams.
-
-  // Avoid start-up glitches by filling up the endpoint buffer with "silence"
-  // before starting the stream.
-  UINT32 endpoint_buffer_size = 0;
-  hr = client->GetBufferSize(&endpoint_buffer_size);
-  DVLOG_IF(1, FAILED(hr)) << "IAudioClient::GetBufferSize: " << std::hex << hr;
-
-  BYTE* data = NULL;
-  hr = audio_render_client->GetBuffer(endpoint_buffer_size, &data);
-  DVLOG_IF(1, FAILED(hr)) << "IAudioRenderClient::GetBuffer: "
-                          << std::hex << hr;
-  if (SUCCEEDED(hr)) {
-    // Using the AUDCLNT_BUFFERFLAGS_SILENT flag eliminates the need to
-    // explicitly write silence data to the rendering buffer.
-    hr = audio_render_client->ReleaseBuffer(endpoint_buffer_size,
-                                            AUDCLNT_BUFFERFLAGS_SILENT);
-    DVLOG_IF(1, FAILED(hr)) << "IAudioRenderClient::ReleaseBuffer: "
-                            << std::hex << hr;
-  }
-
-  // Sanity check: verify that the endpoint buffer is filled with silence.
-  UINT32 num_queued_frames = 0;
-  client->GetCurrentPadding(&num_queued_frames);
-  DCHECK(num_queued_frames == endpoint_buffer_size);
-
   return audio_render_client;
 }
 
 ScopedComPtr<IAudioCaptureClient> CoreAudioUtil::CreateCaptureClient(
     IAudioClient* client) {
-  DCHECK(CoreAudioUtil::IsSupported());
+  DCHECK(IsSupported());
 
   // Get access to the IAudioCaptureClient interface. This interface
   // enables us to read input data from a capturing endpoint buffer.
   ScopedComPtr<IAudioCaptureClient> audio_capture_client;
   HRESULT hr = client->GetService(__uuidof(IAudioCaptureClient),
                                   audio_capture_client.ReceiveVoid());
   if (FAILED(hr)) {
     DVLOG(1) << "IAudioClient::GetService: " << std::hex << hr;
     return ScopedComPtr<IAudioCaptureClient>();
   }
   return audio_capture_client;
 }
 
+bool CoreAudioUtil::FillRenderEndpointBufferWithSilence(
+    IAudioClient* client, IAudioRenderClient* render_client) {
+  DCHECK(IsSupported());
+
+  UINT32 endpoint_buffer_size = 0;
+  if (FAILED(client->GetBufferSize(&endpoint_buffer_size)))
+    return false;
+
+  UINT32 num_queued_frames = 0;
+  if (FAILED(client->GetCurrentPadding(&num_queued_frames)))
+    return false;
+
+  BYTE* data = NULL;
+  int num_frames_to_fill = endpoint_buffer_size - num_queued_frames;
+  if (FAILED(render_client->GetBuffer(num_frames_to_fill, &data)))
+    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";
+  if (FAILED(render_client->ReleaseBuffer(num_frames_to_fill,

[tommi (sloooow) - chröme, 2013/01/31 16:18:24]

return SUCCEEDED(render_client->ReleaseBuffer(...));

[henrika (OOO until Aug 14), 2013/02/01 10:55:56]

Done.

+                                          AUDCLNT_BUFFERFLAGS_SILENT)))
+    return false;
+  return true;
+}
+
 }  // namespace media