MuteSource Audio During Full Screen Cast

media/audio/win/audio_low_latency_input_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_input_win.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 17 matching lines @@
       opened_(false),
       started_(false),
       frame_size_(0),
       packet_size_frames_(0),
       packet_size_bytes_(0),
       endpoint_buffer_size_frames_(0),
       device_id_(device_id),
       perf_count_to_100ns_units_(0.0),
       ms_to_frame_count_(0.0),
       sink_(NULL),
-      audio_bus_(media::AudioBus::Create(params)) {
+      audio_bus_(media::AudioBus::Create(params)),
+      mute_done_(false) {
   DCHECK(manager_);
 
   // 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";
 
   // Set up the desired capture format specified by the client.
   format_.nSamplesPerSec = params.sample_rate();
   format_.wFormatTag = WAVE_FORMAT_PCM;
   format_.wBitsPerSample = params.bits_per_sample();
@@ skipping 79 matching lines @@
 void WASAPIAudioInputStream::Start(AudioInputCallback* callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(callback);
   DLOG_IF(ERROR, !opened_) << "Open() has not been called successfully";
   if (!opened_)
     return;
 
   if (started_)
     return;
 
+  if (device_id_ == AudioDeviceDescription::kLoopbackWithMuteDeviceId &&
+      system_audio_volume_) {
+    BOOL muted = false;
+    system_audio_volume_->GetMute(&muted);
+
+    // If the system audio is muted at the time of capturing, then no need to
+    // mute it again, and later we do not unmute system audio when stopping
+    // capturing.
+    if (!muted) {
+      system_audio_volume_->SetMute(true, NULL);
+      mute_done_ = true;
+    }
+  }
+
   DCHECK(!sink_);
   sink_ = callback;
 
   // Starts periodic AGC microphone measurements if the AGC has been enabled
   // using SetAutomaticGainControl().
   StartAgc();
 
   // Create and start the thread that will drive the capturing by waiting for
   // capture events.
   capture_thread_ = new base::DelegateSimpleThread(
@@ skipping 10 matching lines @@
 
   started_ = SUCCEEDED(hr);
 }
 
 void WASAPIAudioInputStream::Stop() {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "WASAPIAudioInputStream::Stop()";
   if (!started_)
     return;
 
+  // We have muted system audio for capturing, so we need to unmute it when
+  // capturing stops.
+  if (device_id_ == AudioDeviceDescription::kLoopbackWithMuteDeviceId &&
+      mute_done_) {
+    DCHECK(system_audio_volume_);
+    if (system_audio_volume_) {
+      system_audio_volume_->SetMute(false, NULL);
+      mute_done_ = false;
+    }
+  }
+
   // Stops periodic AGC microphone measurements.
   StopAgc();
 
   // Shut down the capture thread.
   if (stop_capture_event_.IsValid()) {
     SetEvent(stop_capture_event_.Get());
   }
 
   // Stop the input audio streaming.
   HRESULT hr = audio_client_->Stop();
@@ skipping 286 matching lines @@
 
   if (device_id_ == AudioDeviceDescription::kDefaultDeviceId) {
     // Retrieve the default capture 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 = enumerator->GetDefaultAudioEndpoint(eCapture, eConsole,
                                              endpoint_device_.Receive());
   } else if (device_id_ == AudioDeviceDescription::kCommunicationsDeviceId) {
     hr = enumerator->GetDefaultAudioEndpoint(eCapture, eCommunications,
                                              endpoint_device_.Receive());
+  } else if (device_id_ == AudioDeviceDescription::kLoopbackWithMuteDeviceId) {
+    // Capture the default playback stream.
+    hr = enumerator->GetDefaultAudioEndpoint(eRender, eConsole,
+                                             endpoint_device_.Receive());
+
+    endpoint_device_->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, NULL,
+                               system_audio_volume_.ReceiveVoid());
   } else if (device_id_ == AudioDeviceDescription::kLoopbackInputDeviceId) {
     // Capture the default playback stream.
     hr = enumerator->GetDefaultAudioEndpoint(eRender, eConsole,
                                              endpoint_device_.Receive());
   } else {
     hr = enumerator->GetDevice(base::UTF8ToUTF16(device_id_).c_str(),
                                endpoint_device_.Receive());
   }
 
   if (FAILED(hr))
@@ skipping 81 matching lines @@
   DLOG_IF(ERROR, hr == S_FALSE) << "Format is not supported "
                                 << "but a closest match exists.";
   return (hr == S_OK);
 }
 
 HRESULT WASAPIAudioInputStream::InitializeAudioEngine() {
   DWORD flags;
   // Use event-driven mode only fo regular input devices. For loopback the
   // EVENTCALLBACK flag is specified when intializing
   // |audio_render_client_for_loopback_|.
-  if (device_id_ == AudioDeviceDescription::kLoopbackInputDeviceId) {
+  if (device_id_ == AudioDeviceDescription::kLoopbackInputDeviceId ||
+      device_id_ == AudioDeviceDescription::kLoopbackWithMuteDeviceId) {
     flags = AUDCLNT_STREAMFLAGS_LOOPBACK | AUDCLNT_STREAMFLAGS_NOPERSIST;
   } else {
     flags = AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST;
   }
 
   // Initialize the audio stream between the client and the device.
   // We connect indirectly through the audio engine by using shared mode.
   // Note that, |hnsBufferDuration| is set of 0, which ensures that the
   // buffer is never smaller than the minimum buffer size needed to ensure
   // that glitches do not occur between the periodic processing passes.
@@ skipping 53 matching lines @@
   // to MSDN:
   //
   //   A pull-mode capture client does not receive any events when a stream is
   //   initialized with event-driven buffering and is loopback-enabled. To
   //   work around this, initialize a render stream in event-driven mode. Each
   //   time the client receives an event for the render stream, it must signal
   //   the capture client to run the capture thread that reads the next set of
   //   samples from the capture endpoint buffer.
   //
   // http://msdn.microsoft.com/en-us/library/windows/desktop/dd316551(v=vs.85).aspx
-  if (device_id_ == AudioDeviceDescription::kLoopbackInputDeviceId) {
+  if (device_id_ == AudioDeviceDescription::kLoopbackInputDeviceId ||
+      device_id_ == AudioDeviceDescription::kLoopbackWithMuteDeviceId) {
     hr = endpoint_device_->Activate(
         __uuidof(IAudioClient), CLSCTX_INPROC_SERVER, NULL,
         audio_render_client_for_loopback_.ReceiveVoid());
     if (FAILED(hr))
       return hr;
 
     hr = audio_render_client_for_loopback_->Initialize(
         AUDCLNT_SHAREMODE_SHARED,
         AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST,
         0, 0, &format_, NULL);
@@ skipping 17 matching lines @@
     return hr;
 
   // Obtain a reference to the ISimpleAudioVolume interface which enables
   // us to control the master volume level of an audio session.
   hr = audio_client_->GetService(__uuidof(ISimpleAudioVolume),
                                  simple_audio_volume_.ReceiveVoid());
   return hr;
 }
 
 }  // namespace media