[Chromoting] Add AudioVolumeApplier to reduce the complexity and the dependency of kChannels

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 26 matching lines @@
 
 // Upper bound for the timer precision error, in milliseconds.
 // Timers are supposed to be accurate to 20ms, so we use 30ms to be safe.
 const int kMaxExpectedTimerLag = 30;
 }  // namespace
 
 namespace remoting {
 
 AudioCapturerWin::AudioCapturerWin()
     : sampling_rate_(AudioPacket::SAMPLING_RATE_INVALID),
-      silence_detector_(kSilenceThreshold),
+      volume_applier_(kSilenceThreshold),
       last_capture_error_(S_OK) {
   thread_checker_.DetachFromThread();
 }
 
 AudioCapturerWin::~AudioCapturerWin() {
   DCHECK(thread_checker_.CalledOnValidThread());
   Deinitialize();
 }
 
 bool AudioCapturerWin::Start(const PacketCapturedCallback& callback) {
@@ skipping 25 matching lines @@
 void AudioCapturerWin::Deinitialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
   wave_format_ex_.Reset(nullptr);
   default_device_detector_.reset();
   audio_capture_client_.Reset();
   if (audio_client_) {
     audio_client_->Stop();
   }
   audio_client_.Reset();
   mm_device_.Reset();
-  audio_volume_.Reset();
 }
 
 bool AudioCapturerWin::Initialize() {
   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());
 
   HRESULT hr = S_OK;
   base::win::ScopedComPtr<IMMDeviceEnumerator> mm_device_enumerator;
   hr = mm_device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator));
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to create IMMDeviceEnumerator. Error " << hr;
     return false;
   }
@@ skipping 115 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 IAudioEndpointVolume.
-  // TODO(zijiehe): Do we need to control per process volume?
-  hr = mm_device_->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, nullptr,
-                            audio_volume_.ReceiveVoid());
-  if (FAILED(hr)) {
-    LOG(ERROR) << "Failed to get an IAudioEndpointVolume. Error " << hr;
-    return false;
-  }
-
-  silence_detector_.Reset(sampling_rate_, kChannels);
+  volume_applier_.ActivateBy(mm_device_.Get());
+  volume_applier_.Initialize(sampling_rate_, kChannels);
 
   return true;
 }
 
 bool AudioCapturerWin::is_initialized() const {
   // All Com components should be initialized / deinitialized together.
-  return !!audio_volume_;
-}
-
-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_->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) {
-  if (frames == 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) {
-    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;
-    }
-  }
-
-  std::unique_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));
+  return !!audio_client_;
 }
 
 void AudioCapturerWin::DoCapture() {
   DCHECK(AudioCapturer::IsValidSampleRate(sampling_rate_));
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!is_initialized() || default_device_detector_->GetAndReset()) {
     if (!ResetAndInitialize()) {
       // Initialization failed, we should wait for next DoCapture call.
       return;
@@ skipping 13 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);
+    if (volume_applier_.Apply(reinterpret_cast<int16_t*>(data), frames)) {
+      std::unique_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));
+    }
 
     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;
 }
 
 std::unique_ptr<AudioCapturer> AudioCapturer::Create() {
   return base::WrapUnique(new AudioCapturerWin());
 }
 
 }  // namespace remoting