Remove the wave based audio capture implementation for Windows

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 <devicetopology.h>
 #include <dxdiag.h>
 #include <functiondiscoverykeys_devpkey.h>
 #include <stddef.h>
@@ skipping 241 matching lines @@
 }
 
 AUDCLNT_SHAREMODE CoreAudioUtil::GetShareMode() {
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kEnableExclusiveAudio))
     return AUDCLNT_SHAREMODE_EXCLUSIVE;
   return AUDCLNT_SHAREMODE_SHARED;
 }
 
 int CoreAudioUtil::NumberOfActiveDevices(EDataFlow data_flow) {
-  DCHECK(IsSupported());
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
   if (!device_enumerator.get())
     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(IsSupported());
-  ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
-      CreateDeviceEnumeratorInternal(true);
-  CHECK(device_enumerator);
-  return device_enumerator;
+  return CreateDeviceEnumeratorInternal(true);
 }
 
 ScopedComPtr<IMMDevice> CoreAudioUtil::CreateDefaultDevice(EDataFlow data_flow,
                                                            ERole role) {
-  DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> endpoint_device;
 
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
   if (!device_enumerator.get())
     return endpoint_device;
 
   // Retrieve the default audio endpoint for the specified data-flow
   // direction and role.
   HRESULT hr = device_enumerator->GetDefaultAudioEndpoint(
       data_flow, role, endpoint_device.Receive());
 
   if (FAILED(hr)) {
     DVLOG(1) << "IMMDeviceEnumerator::GetDefaultAudioEndpoint: "
              << std::hex << hr;
     return endpoint_device;
   }
 
   // Verify that the audio endpoint device is active, i.e., that the audio
   // adapter that connects to the endpoint device is present and enabled.
   if (!IsDeviceActive(endpoint_device.get())) {
     DVLOG(1) << "Selected endpoint device is not active";
     endpoint_device.Release();
   }
   return endpoint_device;
 }
 
 std::string CoreAudioUtil::GetDefaultOutputDeviceID() {
-  DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> device(CreateDefaultDevice(eRender, eConsole));
   return device.get() ? GetDeviceID(device.get()) : std::string();
 }
 
 ScopedComPtr<IMMDevice> CoreAudioUtil::CreateDevice(
     const std::string& device_id) {
-  DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> endpoint_device;
 
   // Create the IMMDeviceEnumerator interface.
   ScopedComPtr<IMMDeviceEnumerator> device_enumerator =
       CreateDeviceEnumerator();
   if (!device_enumerator.get())
     return endpoint_device;
 
   // Retrieve an audio device specified by an endpoint device-identification
   // string.
@@ skipping 10 matching lines @@
   // Verify that the audio endpoint device is active, i.e., that the audio
   // adapter that connects to the endpoint device is present and enabled.
   if (!IsDeviceActive(endpoint_device.get())) {
     DVLOG(1) << "Selected endpoint device is not active";
     endpoint_device.Release();
   }
   return endpoint_device;
 }
 
 HRESULT CoreAudioUtil::GetDeviceName(IMMDevice* device, AudioDeviceName* name) {
-  DCHECK(IsSupported());
-
   // Retrieve unique name of endpoint device.
   // Example: "{0.0.1.00000000}.{8db6020f-18e3-4f25-b6f5-7726c9122574}".
   AudioDeviceName device_name;
   device_name.unique_id = GetDeviceID(device);
   if (device_name.unique_id.empty())
     return E_FAIL;
 
   HRESULT hr = GetDeviceFriendlyNameInternal(device, &device_name.device_name);
   if (FAILED(hr))
     return hr;
 
   *name = device_name;
   DVLOG(2) << "friendly name: " << device_name.device_name;
   DVLOG(2) << "unique id    : " << device_name.unique_id;
   return hr;
 }
 
 std::string CoreAudioUtil::GetAudioControllerID(IMMDevice* device,
     IMMDeviceEnumerator* enumerator) {
-  DCHECK(IsSupported());
-
   // Fetching the controller device id could be as simple as fetching the value
   // of the "{B3F8FA53-0004-438E-9003-51A46E139BFC},2" property in the property
   // store of the |device|, but that key isn't defined in any header and
   // according to MS should not be relied upon.
   // So, instead, we go deeper, look at the device topology and fetch the
   // PKEY_Device_InstanceId of the associated physical audio device.
   ScopedComPtr<IDeviceTopology> topology;
   ScopedComPtr<IConnector> connector;
   ScopedCoMem<WCHAR> filter_id;
   if (FAILED(device->Activate(__uuidof(IDeviceTopology), CLSCTX_ALL, NULL,
@@ skipping 78 matching lines @@
         GetAudioControllerID(output_device.get(), enumerator.get()));
     if (output_controller_id == controller_id)
       break;
     output_device = NULL;
   }
 
   return output_device.get() ? GetDeviceID(output_device.get()) : std::string();
 }
 
 std::string CoreAudioUtil::GetFriendlyName(const std::string& device_id) {
-  DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> audio_device = CreateDevice(device_id);
   if (!audio_device.get())
     return std::string();
 
   AudioDeviceName device_name;
   HRESULT hr = GetDeviceName(audio_device.get(), &device_name);
   if (FAILED(hr))
     return std::string();
 
   return device_name.device_name;
 }
 
 bool CoreAudioUtil::DeviceIsDefault(EDataFlow flow,
                                     ERole role,
                                     const std::string& device_id) {
-  DCHECK(IsSupported());
   ScopedComPtr<IMMDevice> device = CreateDefaultDevice(flow, role);
   if (!device.get())
     return false;
 
   std::string str_default(GetDeviceID(device.get()));
   return device_id.compare(str_default) == 0;
 }
 
 EDataFlow CoreAudioUtil::GetDataFlow(IMMDevice* device) {
-  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(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(IsSupported());
   ScopedComPtr<IMMDevice> default_device(CreateDefaultDevice(data_flow, role));
   return (default_device.get() ? CreateClient(default_device.get())
                                : ScopedComPtr<IAudioClient>());
 }
 
 ScopedComPtr<IAudioClient> CoreAudioUtil::CreateClient(
     const std::string& device_id, EDataFlow data_flow, ERole role) {
   if (IsDefaultDeviceId(device_id))
     return CreateDefaultClient(data_flow, role);
 
   ScopedComPtr<IMMDevice> device(CreateDevice(device_id));
   if (!device.get())
     return ScopedComPtr<IAudioClient>();
 
   return CreateClient(device.get());
 }
 
 HRESULT CoreAudioUtil::GetSharedModeMixFormat(
     IAudioClient* client, WAVEFORMATPCMEX* format) {
-  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) << *format;
 
   return hr;
 }
 
 bool CoreAudioUtil::IsFormatSupported(IAudioClient* client,
                                       AUDCLNT_SHAREMODE share_mode,
                                       const WAVEFORMATPCMEX* format) {
-  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) << *closest_match;
   }
 
   return (hr == S_OK);
 }
 
 bool CoreAudioUtil::IsChannelLayoutSupported(const std::string& device_id,
                                              EDataFlow data_flow,
                                              ERole role,
                                              ChannelLayout channel_layout) {
-  DCHECK(IsSupported());
-
   // First, get the preferred mixing format for shared mode streams.
-
   ScopedComPtr<IAudioClient> client(CreateClient(device_id, data_flow, role));
   if (!client.get())
     return false;
 
   WAVEFORMATPCMEX format;
   HRESULT hr = GetSharedModeMixFormat(client.get(), &format);
   if (FAILED(hr))
     return false;
 
   // Next, check if it is possible to use an alternative format where the
@@ skipping 25 matching lines @@
   // an even wider range of shared-mode formats where the installation package
   // for the audio device includes a local effects (LFX) audio processing
   // object (APO) that can handle format conversions.
   return CoreAudioUtil::IsFormatSupported(client.get(),
                                           AUDCLNT_SHAREMODE_SHARED, &format);
 }
 
 HRESULT CoreAudioUtil::GetDevicePeriod(IAudioClient* client,
                                        AUDCLNT_SHAREMODE share_mode,
                                        REFERENCE_TIME* device_period) {
-  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(IsSupported());
   WAVEFORMATPCMEX mix_format;
   HRESULT hr = GetSharedModeMixFormat(client, &mix_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 46 matching lines @@
                                bits_per_sample,
                                frames_per_buffer);
 
   *params = audio_params;
   return hr;
 }
 
 HRESULT CoreAudioUtil::GetPreferredAudioParameters(const std::string& device_id,
                                                    bool is_output_device,
                                                    AudioParameters* params) {
-  DCHECK(IsSupported());
-
   ScopedComPtr<IMMDevice> device;
   if (device_id == AudioDeviceDescription::kDefaultDeviceId) {
     device = CoreAudioUtil::CreateDefaultDevice(
         is_output_device ? eRender : eCapture, eConsole);
   } else if (device_id == AudioDeviceDescription::kLoopbackInputDeviceId ||
       device_id == AudioDeviceDescription::kLoopbackWithMuteDeviceId) {
     DCHECK(!is_output_device);
     device = CoreAudioUtil::CreateDefaultDevice(eRender, eConsole);
   } else if (device_id == AudioDeviceDescription::kCommunicationsDeviceId) {
     device = CoreAudioUtil::CreateDefaultDevice(
@@ skipping 43 matching lines @@
     return 0;
 
   return static_cast<ChannelConfig>(format.dwChannelMask);
 }
 
 HRESULT CoreAudioUtil::SharedModeInitialize(IAudioClient* client,
                                             const WAVEFORMATPCMEX* format,
                                             HANDLE event_handle,
                                             uint32_t* endpoint_buffer_size,
                                             const GUID* session_guid) {
-  DCHECK(IsSupported());
-
   // Use default flags (i.e, dont set AUDCLNT_STREAMFLAGS_NOPERSIST) to
   // ensure that the volume level and muting state for a rendering session
   // are persistent across system restarts. The volume level and muting
   // state for a capture session are never persistent.
   DWORD stream_flags = 0;
 
   // 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.
@@ skipping 37 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(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>();
   }
   return audio_render_client;
 }
 
 ScopedComPtr<IAudioCaptureClient> CoreAudioUtil::CreateCaptureClient(
     IAudioClient* client) {
-  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;
@@ skipping 53 matching lines @@
 
   if (variant.type() == VT_BSTR && variant.ptr()->bstrVal) {
     base::WideToUTF8(variant.ptr()->bstrVal, wcslen(variant.ptr()->bstrVal),
                      driver_version);
   }
 
   return true;
 }
 
 }  // namespace media