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;
+  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;
+    }
+  }
+  if (silence_detector_.IsSilence(samples, sample_count)) {

[Sergey Ulanov, 2016/03/10 01:13:40]

I still think this should be done before volume is applied for the same reasons
I explained in my previous comment (i.e. this condition should apper before
GetAudioLevel()). In 99% of calls this function will return true and the data is
not going to be sent. In that case we don't want to waste time applying volume.
If you are worried about the case when the volume is close to 0, but no 0, then
maybe set low threshold for volume in line 249, e.g.:
  if (level < 0.01)
    return;
But IMO this is not going to make much difference.

[Hzj_jie, 2016/03/10 01:58:59]

Emm, I see your point clearly. Most of time, we will have silent samples.
Reasonable. I have moved silence detector above the logic to apply volume.

+    return;
+  }
+
+  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