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;

[joedow, 2016/03/04 16:46:10]

Is there an advantage to returning an int here instead of a float (i.e. 1 vs.
1.0f)?  Same for the rest of the return statements.  I think it would be cleaner
to actually return a float value.

[Sergey Ulanov, 2016/03/04 21:30:03]

FWIW IMO it makes no difference. Compiler will generate the same code in both
cases. "return 1;" may be easier to read.

[Hzj_jie, 2016/03/09 19:47:57]

Done.

+  } else if (mute) {

[Sergey Ulanov, 2016/03/04 21:30:03]

don't need this else.
See https://www.chromium.org/developers/coding-style#TOC-Code-formatting 
The last item in that section: "Don't use else after return"

[Hzj_jie, 2016/03/09 19:47:57]

Done.

+    return 0;
+  }

[joedow, 2016/03/04 16:46:10]

nit: add a newline here to break up the mute and volume level logic blocks.

[Hzj_jie, 2016/03/09 19:47:57]

Done.

+  float level;
+  hr = audio_volume_->GetMasterVolume(&level);
+  if (FAILED(hr) || level > 1) {
+    return 1;
+  } else if (level < 0) {
+    return 0;
+  } else {

[Sergey Ulanov, 2016/03/04 21:30:03]

don't need this else

[Hzj_jie, 2016/03/09 19:47:57]

Done.

+    return level;
+  }
+}
+
+void AudioCapturerWin::ProcessSamples(BYTE* data, UINT32 frames, DWORD flags) {
+  if (frames == 0) {
+    return;
+  }
+
+  if ((flags & AUDCLNT_BUFFERFLAGS_SILENT) == 0) {
+    return;
+  }
+
+  float level = GetAudioLevel();
+  if (level == 0) {

[joedow, 2016/03/04 16:46:10]

Are there problems here if the level is 0.01 or 0.06?  I'm wondering if there
might be cast problems when comparing to an integer which might be compiler
specific (whether it rounds or truncates).  The safest seems like a float
comparison with a small delta for tolerance.

[Sergey Ulanov, 2016/03/04 21:30:03]

Compiler is required to convert ints to floats for mixed-type operations like
this, so I don't think there a problem here.

[Hzj_jie, 2016/03/09 19:47:57]

I believe what Joe mentioned is the string display limitation of float point
numbers. i.e. what you see for by calling a cout or printf is not what you get
in a float number. A description can be found in Python tutorial
(https://docs.python.org/3/tutorial/floatingpoint.html). But 0 is definitely
safe. It's always 0. http://cpp.sh/9irk

+    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/04 21:30:03]

this can be reformatted as follows

if (silence_detector_.IsSilence(samples, sample_count))
  return;

...send data.

[Hzj_jie, 2016/03/09 19:47:57]

Done.

+    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