Support audio in curtain mode, and use endpoint volume instead of session volume to adjust audio st…

remoting/host/audio_capturer_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 "remoting/host/audio_capturer_win.h"
 
 #include <avrt.h>
 #include <mmreg.h>
 #include <mmsystem.h>
 #include <stdint.h>
@@ skipping 30 matching lines @@
 
 AudioCapturerWin::AudioCapturerWin()
     : sampling_rate_(AudioPacket::SAMPLING_RATE_INVALID),
       silence_detector_(kSilenceThreshold),
       last_capture_error_(S_OK) {
     thread_checker_.DetachFromThread();
 }
 
 AudioCapturerWin::~AudioCapturerWin() {
   DCHECK(thread_checker_.CalledOnValidThread());
+  if (audio_client_) {
+    audio_client_->Stop();
+  }
 }
 
 bool AudioCapturerWin::Start(const PacketCapturedCallback& callback) {
   DCHECK(!audio_capture_client_.get());
   DCHECK(!audio_client_.get());
   DCHECK(!mm_device_.get());
   DCHECK(!audio_volume_.get());
   DCHECK(static_cast<PWAVEFORMATEX>(wave_format_ex_) == nullptr);
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 126 matching lines @@
     return false;
   }
 
   // Start the IAudioClient.
   hr = audio_client_->Start();
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to start IAudioClient. Error " << hr;
     return false;
   }
 
-  // Initialize ISimpleAudioVolume.
+  // Initialize IAudioEndpointVolume.
   // TODO(zijiehe): Do we need to control per process volume?
-  hr = audio_client_->GetService(__uuidof(ISimpleAudioVolume),
-                                 audio_volume_.ReceiveVoid());
+  hr = mm_device_->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, nullptr,
+                            audio_volume_.ReceiveVoid());
   if (FAILED(hr)) {
-    LOG(ERROR) << "Failed to get an ISimpleAudioVolume. Error " << hr;
+    LOG(ERROR) << "Failed to get an IAudioEndpointVolume. Error " << hr;
     return false;
   }
 
   silence_detector_.Reset(sampling_rate_, kChannels);
 
   // Start capturing.
   capture_timer_->Start(FROM_HERE,
                         audio_device_period_,
                         this,
                         &AudioCapturerWin::DoCapture);
   return true;
 }
 
 float AudioCapturerWin::GetAudioLevel() {
   BOOL mute;
   HRESULT hr = audio_volume_->GetMute(&mute);
   if (FAILED(hr)) {
+    LOG(ERROR) << "Failed to get mute status from IAudioEndpointVolume, error "
+               << hr;
     return 1;
   }
   if (mute) {
     return 0;
   }
 
   float level;
-  hr = audio_volume_->GetMasterVolume(&level);
+  hr = audio_volume_->GetMasterVolumeLevelScalar(&level);
   if (FAILED(hr) || level > 1) {
+    LOG(ERROR) << "Failed to get master volume from IAudioEndpointVolume, "
+                  "error "
+               << hr;
     return 1;
   }
   if (level < 0) {
     return 0;
   }
   return level;
 }
 
-void AudioCapturerWin::ProcessSamples(uint8_t* data,
-                                      size_t frames,
-                                      int32_t flags) {
+void AudioCapturerWin::ProcessSamples(uint8_t* data, size_t frames) {
   if (frames == 0) {
     return;
   }
 
-  if ((flags & AUDCLNT_BUFFERFLAGS_SILENT) == 0) {
-    return;
-  }
-
   int16_t* samples = reinterpret_cast<int16_t*>(data);
   static_assert(sizeof(samples[0]) == kBytesPerSample,
                 "expect 16 bits per sample");
   size_t sample_count = frames * kChannels;
   if (silence_detector_.IsSilence(samples, sample_count)) {
     return;
   }
 
+  // Windows API does not provide volume adjusted audio sample as Linux does.
+  // So we need to manually apply volume to the samples.
   float level = GetAudioLevel();
   if (level == 0) {
     return;
   }
 
   if (level < 1) {
-    // Windows API does not provide volume adjusted audio sample as Linux does.
-    // So we need to manually append volume signal to the samples.
     int32_t level_int = static_cast<int32_t>(level * 65536);
     for (size_t i = 0; i < sample_count; i++) {
       samples[i] = (static_cast<int32_t>(samples[i]) * level_int) >> 16;
     }
   }
 
   scoped_ptr<AudioPacket> packet(new AudioPacket());
   packet->add_data(data, frames * wave_format_ex_->nBlockAlign);
   packet->set_encoding(AudioPacket::ENCODING_RAW);
   packet->set_sampling_rate(sampling_rate_);
@@ skipping 20 matching lines @@
     }
 
     BYTE* data;
     UINT32 frames;
     DWORD flags;
     hr = audio_capture_client_->GetBuffer(&data, &frames, &flags, nullptr,
                                           nullptr);
     if (FAILED(hr))
       break;
 
-    ProcessSamples(data, frames, flags);
+    ProcessSamples(data, frames);
 
     hr = audio_capture_client_->ReleaseBuffer(frames);
     if (FAILED(hr))
       break;
   }
 
   // There is nothing to capture if the audio endpoint device has been unplugged
   // or disabled.
   if (hr == AUDCLNT_E_DEVICE_INVALIDATED)
     return;
 
   // Avoid reporting the same error multiple times.
   if (FAILED(hr) && hr != last_capture_error_) {
     last_capture_error_ = hr;
     LOG(ERROR) << "Failed to capture an audio packet: 0x"
                << std::hex << hr << std::dec << ".";
   }
 }
 
 bool AudioCapturer::IsSupported() {
   return true;
 }
 
 scoped_ptr<AudioCapturer> AudioCapturer::Create() {
   return make_scoped_ptr(new AudioCapturerWin());
 }
 
 }  // namespace remoting