MuteSource Audio During Full Screen Cast

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 12 matching lines @@
 #include "media/base/media_switches.h"
 
 using base::win::ScopedCoMem;
 using base::win::ScopedHandle;
 
 namespace media {
 
 // See header file for documentation.
 // {BE39AF4F-087C-423F-9303-234EC1E5B8EE}
 const GUID kCommunicationsSessionId = {
-  0xbe39af4f, 0x87c, 0x423f, { 0x93, 0x3, 0x23, 0x4e, 0xc1, 0xe5, 0xb8, 0xee }
-};
+    0xbe39af4f,
+    0x87c,
+    0x423f,
+    {0x93, 0x3, 0x23, 0x4e, 0xc1, 0xe5, 0xb8, 0xee}};
 
 enum { KSAUDIO_SPEAKER_UNSUPPORTED = 0 };
 
 // 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
@@ skipping 143 matching lines @@
   HRESULT hr = device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator),
                                                 NULL, CLSCTX_INPROC_SERVER);
   if (hr == CO_E_NOTINITIALIZED && allow_reinitialize) {
     LOG(ERROR) << "CoCreateInstance fails with CO_E_NOTINITIALIZED";
     // We have seen crashes which indicates that this method can in fact
     // fail with CO_E_NOTINITIALIZED in combination with certain 3rd party
     // modules. Calling CoInitializeEx is an attempt to resolve the reported
     // issues. See http://crbug.com/378465 for details.
     hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
     if (SUCCEEDED(hr)) {
-      hr = device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator),
-                                            NULL, CLSCTX_INPROC_SERVER);
+      hr = device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator), NULL,
+                                            CLSCTX_INPROC_SERVER);
     }
   }
   return device_enumerator;
 }
 
 static bool IsSupportedInternal() {
   // It is possible to force usage of WaveXxx APIs by using a command line flag.
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kForceWaveAudio)) {
     DVLOG(1) << "Forcing usage of Windows WaveXxx APIs";
@@ skipping 53 matching lines @@
   // 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());
+  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;
@@ skipping 18 matching lines @@
       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;
+    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;
@@ skipping 13 matching lines @@
   // 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.
   HRESULT hr = device_enumerator->GetDevice(
       base::UTF8ToUTF16(device_id).c_str(), endpoint_device.Receive());
-  DVLOG_IF(1, FAILED(hr)) << "IMMDeviceEnumerator::GetDevice: "
-                          << std::hex << hr;
+  DVLOG_IF(1, FAILED(hr)) << "IMMDeviceEnumerator::GetDevice: " << std::hex
+                          << hr;
 
   if (FAILED(hr)) {
     DVLOG(1) << "IMMDeviceEnumerator::GetDevice: " << 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";
@@ skipping 15 matching lines @@
   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,
+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,
-             topology.ReceiveVoid())) ||
+                              topology.ReceiveVoid())) ||
       // For our purposes checking the first connected device should be enough
       // and if there are cases where there are more than one device connected
       // we're not sure how to handle that anyway. So we pass 0.
       FAILED(topology->GetConnector(0, connector.Receive())) ||
       FAILED(connector->GetDeviceIdConnectedTo(&filter_id))) {
     DLOG(ERROR) << "Failed to get the device identifier of the audio device";
     return std::string();
   }
 
   // Now look at the properties of the connected device node and fetch the
   // instance id (PKEY_Device_InstanceId) of the device node that uniquely
   // identifies the controller.
   ScopedComPtr<IMMDevice> device_node;
   ScopedComPtr<IPropertyStore> properties;
   base::win::ScopedPropVariant instance_id;
   if (FAILED(enumerator->GetDevice(filter_id, device_node.Receive())) ||
       FAILED(device_node->OpenPropertyStore(STGM_READ, properties.Receive())) ||
       FAILED(properties->GetValue(PKEY_Device_InstanceId,
                                   instance_id.Receive())) ||
       instance_id.get().vt != VT_LPWSTR) {
     DLOG(ERROR) << "Failed to get instance id of the audio device node";
     return std::string();
   }
 
   std::string controller_id;
-  base::WideToUTF8(instance_id.get().pwszVal,
-                   wcslen(instance_id.get().pwszVal),
+  base::WideToUTF8(instance_id.get().pwszVal, wcslen(instance_id.get().pwszVal),
                    &controller_id);
 
   return controller_id;
 }
 
 std::string CoreAudioUtil::GetMatchingOutputDeviceID(
     const std::string& input_device_id) {
   // Special handling for the default communications device.
   // We always treat the configured communications devices, as a pair.
   // If we didn't do that and the user has e.g. configured a mic of a headset
@@ skipping 20 matching lines @@
   ScopedComPtr<IMMDeviceEnumerator> enumerator(CreateDeviceEnumerator());
   std::string controller_id(
       GetAudioControllerID(input_device.get(), enumerator.get()));
   if (controller_id.empty())
     return std::string();
 
   // Now enumerate the available (and active) output devices and see if any of
   // them is associated with the same controller.
   ScopedComPtr<IMMDeviceCollection> collection;
   enumerator->EnumAudioEndpoints(eRender, DEVICE_STATE_ACTIVE,
-      collection.Receive());
+                                 collection.Receive());
   if (!collection.get())
     return std::string();
 
   UINT count = 0;
   collection->GetCount(&count);
   ScopedComPtr<IMMDevice> output_device;
   for (UINT i = 0; i < count; ++i) {
     collection->Item(i, output_device.Receive());
     std::string output_controller_id(
         GetAudioControllerID(output_device.get(), enumerator.get()));
@@ skipping 49 matching lines @@
   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());
+  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) {
+    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) {
+    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) {
+HRESULT CoreAudioUtil::GetSharedModeMixFormat(IAudioClient* client,
+                                              WAVEFORMATPCMEX* format) {
   DCHECK(IsSupported());
   ScopedCoMem<WAVEFORMATPCMEX> format_pcmex;
-  HRESULT hr = client->GetMixFormat(
-      reinterpret_cast<WAVEFORMATEX**>(&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;
@@ skipping 46 matching lines @@
     return false;
   }
   format.dwChannelMask = new_config;
 
   // Modify the format if the new channel layout has changed the number of
   // utilized channels.
   const int channels = ChannelLayoutToChannelCount(channel_layout);
   if (channels != format.Format.nChannels) {
     format.Format.nChannels = channels;
     format.Format.nBlockAlign = (format.Format.wBitsPerSample / 8) * channels;
-    format.Format.nAvgBytesPerSec = format.Format.nSamplesPerSec *
-                                    format.Format.nBlockAlign;
+    format.Format.nAvgBytesPerSec =
+        format.Format.nSamplesPerSec * format.Format.nBlockAlign;
   }
   DVLOG(2) << format;
 
   // Some devices can initialize a shared-mode stream with a format that is
   // not identical to the mix format obtained from the GetMixFormat() method.
   // However, chances of succeeding increases if we use the same number of
   // channels and the same sample rate as the mix format. I.e, this call will
   // return true only in those cases where the audio engine is able to support
   // 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;
+  *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) {
+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;
 
   // Get the 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.aspx
   // for more details.
   ChannelConfig channel_config = mix_format.dwChannelMask;
 
   // Convert Microsoft's channel configuration to genric ChannelLayout.
   ChannelLayout channel_layout = ChannelConfigToChannelLayout(channel_config);
 
   // Some devices don't appear to set a valid channel layout, so guess based on
   // the number of channels.  See http://crbug.com/311906.
   if (channel_layout == CHANNEL_LAYOUT_UNSUPPORTED) {
-    DVLOG(1) << "Unsupported channel config: "
-             << std::hex << channel_config
-             << ".  Guessing layout by channel count: "
-             << std::dec << mix_format.Format.nChannels;
+    DVLOG(1) << "Unsupported channel config: " << std::hex << channel_config
+             << ".  Guessing layout by channel count: " << std::dec
+             << mix_format.Format.nChannels;
     channel_layout = GuessChannelLayout(mix_format.Format.nChannels);
   }
 
   // Preferred sample rate.
   int sample_rate = mix_format.Format.nSamplesPerSec;
 
   // TODO(henrika): possibly use format.Format.wBitsPerSample here instead.
   // We use a hard-coded value of 16 bits per sample today even if most audio
   // engines does the actual mixing in 32 bits per sample.
   int bits_per_sample = 16;
 
   // We are using the native device period to derive the smallest possible
   // buffer size in shared mode. Note that the actual endpoint buffer will be
   // larger than this size but it will be possible to fill it up in two calls.
   // TODO(henrika): ensure that this scheme works for capturing as well.
-  int frames_per_buffer = static_cast<int>(sample_rate *
-      RefererenceTimeToTimeDelta(default_period).InSecondsF() + 0.5);
+  int frames_per_buffer = static_cast<int>(
+      sample_rate * RefererenceTimeToTimeDelta(default_period).InSecondsF() +
+      0.5);
 
   DVLOG(1) << "channel_layout   : " << channel_layout;
   DVLOG(1) << "sample_rate      : " << sample_rate;
   DVLOG(1) << "bits_per_sample  : " << bits_per_sample;
   DVLOG(1) << "frames_per_buffer: " << frames_per_buffer;
 
   AudioParameters audio_params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
-                               channel_layout,
-                               sample_rate,
-                               bits_per_sample,
+                               channel_layout, sample_rate, 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) {
+  } 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(
         is_output_device ? eRender : eCapture, eCommunications);
   } else {
     device = CreateDevice(device_id);
   }
 
   if (!device.get()) {
@@ skipping 50 matching lines @@
   // 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.
   // Both shared-mode and exclusive-mode streams can use event-driven buffering.
-  bool use_event = (event_handle != NULL &&
-                    event_handle != INVALID_HANDLE_VALUE);
+  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 shared mode client for minimal delay.
-  HRESULT hr = client->Initialize(AUDCLNT_SHAREMODE_SHARED,
-                                  stream_flags,
-                                  0,
-                                  0,
+  HRESULT hr = client->Initialize(AUDCLNT_SHAREMODE_SHARED, stream_flags, 0, 0,
                                   reinterpret_cast<const WAVEFORMATEX*>(format),
                                   session_guid);
   if (FAILED(hr)) {
     DVLOG(1) << "IAudioClient::Initialize: " << std::hex << hr;
     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 = buffer_size_in_frames;
   DVLOG(2) << "endpoint buffer size: " << buffer_size_in_frames;
 
   // TODO(henrika): utilize when delay measurements are added.
-  REFERENCE_TIME  latency = 0;
+  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());
 
@@ skipping 19 matching lines @@
   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) {
+    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;
 
@@ skipping 55 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