Add volume control for windows host

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 36 matching lines @@
 }
 
 AudioCapturerWin::~AudioCapturerWin() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 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());
 
   callback_ = callback;
 
   // Initialize the capture timer.
   capture_timer_.reset(new base::RepeatingTimer());
 
   HRESULT hr = S_OK;
 
@@ skipping 119 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.
+  // TODO(zijiehe): Do we need to control per process volume?
+  hr = audio_client_->GetService(__uuidof(ISimpleAudioVolume),
+                                 audio_volume_.ReceiveVoid());
+  if (FAILED(hr)) {
+    LOG(ERROR) << "Failed to get an ISimpleAudioVolume. 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)) {
+    return 1;
+  }
+  if (mute) {
+    return 0;
+  }
+
+  float level;
+  hr = audio_volume_->GetMasterVolume(&level);
+  if (FAILED(hr) || level > 1) {
+    return 1;
+  }
+  if (level < 0) {
+    return 0;
+  }
+  return level;
+}
+
+void AudioCapturerWin::ProcessSamples(uint8_t* data,
+                                      size_t frames,
+                                      int32_t flags) {
+  if (frames == 0) {
+    return;
+  }
+
+  if ((flags & AUDCLNT_BUFFERFLAGS_SILENT) == 0) {
+    return;
+  }
+
+  float level = GetAudioLevel();
+  if (level == 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;

[Sergey Ulanov, 2016/03/10 06:04:28]

nit: move samples and sample_count inside the if block below where they are
used.

[Hzj_jie, 2016/03/10 18:30:41]

Both silence_detector_.IsSilence and following logic use samples and
sample_count.

+  if (silence_detector_.IsSilence(samples, sample_count)) {

[Sergey Ulanov, 2016/03/10 06:04:28]

nit: move this above GetAudioLevel() call to avoid calling system APIs to get
volume when we get silence. It most cases we will get silence here but audio is
not muted. To optimize for that case we want to detect silence as soon as
possible, i.e. before GetAudioLevel()

[Hzj_jie, 2016/03/10 18:30:41]

Done.

+    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_);
+  packet->set_bytes_per_sample(AudioPacket::BYTES_PER_SAMPLE_2);
+  packet->set_channels(AudioPacket::CHANNELS_STEREO);
+
+  callback_.Run(std::move(packet));
+}
+
 void AudioCapturerWin::DoCapture() {
   DCHECK(AudioCapturer::IsValidSampleRate(sampling_rate_));
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Fetch all packets from the audio capture endpoint buffer.
   HRESULT hr = S_OK;
   while (true) {
     UINT32 next_packet_size;
     HRESULT hr = audio_capture_client_->GetNextPacketSize(&next_packet_size);
     if (FAILED(hr))
       break;
 
     if (next_packet_size <= 0) {
       return;
     }
 
     BYTE* data;
     UINT32 frames;
     DWORD flags;
     hr = audio_capture_client_->GetBuffer(&data, &frames, &flags, nullptr,
                                           nullptr);
     if (FAILED(hr))
       break;
 
-    if ((flags & AUDCLNT_BUFFERFLAGS_SILENT) == 0 &&
-        !silence_detector_.IsSilence(reinterpret_cast<const int16_t*>(data),
-                                     frames * kChannels)) {
-      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_);
-      packet->set_bytes_per_sample(AudioPacket::BYTES_PER_SAMPLE_2);
-      packet->set_channels(AudioPacket::CHANNELS_STEREO);
-
-      callback_.Run(std::move(packet));
-    }
+    ProcessSamples(data, frames, flags);
 
     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