[Chromoting] Implement down mixing in AudioPump

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 <objbase.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <windows.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/synchronization/lock.h"
 #include "remoting/host/win/default_audio_device_change_detector.h"
 
 namespace {
-const int kChannels = 2;
 const int kBytesPerSample = 2;
 const int kBitsPerSample = kBytesPerSample * 8;
 // Conversion factor from 100ns to 1ms.
 const int k100nsPerMillisecond = 10000;
 
 // Tolerance for catching packets of silence. If all samples have absolute
 // value less than this threshold, the packet will be counted as a packet of
 // silence. A value of 2 was chosen, because Windows can give samples of 1 and
 // -1, even when no audio is playing.
 const int kSilenceThreshold = 2;
 
 // Lower bound for timer intervals, in milliseconds.
 const int kMinTimerInterval = 30;
 
 // 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;
+
+// Chooses a similar and supported channel configuration. |channels| represents
+// the selected channels. It can be nullptr.
+void ChooseChannels(WORD* channel_count, DWORD* channels) {
+  // We supports mono to 7.1.
+  if (*channel_count >= 1 && *channel_count <= 8) {
+    return;
+  }
+
+  *channel_count = remoting::AudioPacket::CHANNELS_STEREO;
+  if (channels) {
+    *channels = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
+  }
+}
+
 }  // namespace
 
 namespace remoting {
 
 AudioCapturerWin::AudioCapturerWin()
     : sampling_rate_(AudioPacket::SAMPLING_RATE_INVALID),
       volume_filter_(kSilenceThreshold),
       last_capture_error_(S_OK) {
   thread_checker_.DetachFromThread();
 }
@@ skipping 104 matching lines @@
       // Intentional fall-through.
     case WAVE_FORMAT_PCM:
       if (!AudioCapturer::IsValidSampleRate(wave_format_ex_->nSamplesPerSec)) {
         LOG(ERROR) << "Host sampling rate is neither 44.1 kHz nor 48 kHz.";
         return false;
       }
       sampling_rate_ = static_cast<AudioPacket::SamplingRate>(
           wave_format_ex_->nSamplesPerSec);
 
       wave_format_ex_->wFormatTag = WAVE_FORMAT_PCM;
-      wave_format_ex_->nChannels = kChannels;
+      ChooseChannels(&wave_format_ex_->nChannels, nullptr);
       wave_format_ex_->wBitsPerSample = kBitsPerSample;
-      wave_format_ex_->nBlockAlign = kChannels * kBytesPerSample;
+      wave_format_ex_->nBlockAlign =
+          wave_format_ex_->nChannels * kBytesPerSample;
       wave_format_ex_->nAvgBytesPerSec =
-          sampling_rate_ * kChannels * kBytesPerSample;
+          sampling_rate_ * wave_format_ex_->nChannels * kBytesPerSample;
       break;
     case WAVE_FORMAT_EXTENSIBLE: {
       PWAVEFORMATEXTENSIBLE wave_format_extensible =
           reinterpret_cast<WAVEFORMATEXTENSIBLE*>(
           static_cast<WAVEFORMATEX*>(wave_format_ex_));
       if (IsEqualGUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT,
                       wave_format_extensible->SubFormat)) {
         if (!AudioCapturer::IsValidSampleRate(
                 wave_format_extensible->Format.nSamplesPerSec)) {
           LOG(ERROR) << "Host sampling rate is neither 44.1 kHz nor 48 kHz.";
           return false;
         }
         sampling_rate_ = static_cast<AudioPacket::SamplingRate>(
             wave_format_extensible->Format.nSamplesPerSec);
 
         wave_format_extensible->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
         wave_format_extensible->Samples.wValidBitsPerSample = kBitsPerSample;
 
-        wave_format_extensible->Format.nChannels = kChannels;
+        ChooseChannels(&wave_format_extensible->Format.nChannels,
+                       &wave_format_extensible->dwChannelMask);
         wave_format_extensible->Format.nSamplesPerSec = sampling_rate_;
         wave_format_extensible->Format.wBitsPerSample = kBitsPerSample;
         wave_format_extensible->Format.nBlockAlign =
-            kChannels * kBytesPerSample;
+            wave_format_extensible->Format.nChannels * kBytesPerSample;
         wave_format_extensible->Format.nAvgBytesPerSec =
-            sampling_rate_ * kChannels * kBytesPerSample;
+            sampling_rate_ * wave_format_extensible->Format.nChannels *
+            kBytesPerSample;
       } else {
         LOG(ERROR) << "Failed to force 16-bit samples";
         return false;
       }
       break;
     }
     default:
       LOG(ERROR) << "Failed to force 16-bit PCM";
       return false;
   }
@@ skipping 20 matching lines @@
   }
 
   // Start the IAudioClient.
   hr = audio_client_->Start();
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to start IAudioClient. Error " << hr;
     return false;
   }
 
   volume_filter_.ActivateBy(mm_device_.Get());
-  volume_filter_.Initialize(sampling_rate_, kChannels);
+  volume_filter_.Initialize(sampling_rate_, wave_format_ex_->nChannels);
 
   return true;
 }
 
 bool AudioCapturerWin::is_initialized() const {
   // All Com components should be initialized / deinitialized together.
   return !!audio_client_;
 }
 
 void AudioCapturerWin::DoCapture() {
@@ skipping 26 matching lines @@
                                           nullptr);
     if (FAILED(hr))
       break;
 
     if (volume_filter_.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);
+      packet->set_channels(static_cast<AudioPacket::Channels>(
+          wave_format_ex_->nChannels));
 
       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
@@ skipping 11 matching lines @@
 
 bool AudioCapturer::IsSupported() {
   return true;
 }
 
 std::unique_ptr<AudioCapturer> AudioCapturer::Create() {
   return base::WrapUnique(new AudioCapturerWin());
 }
 
 }  // namespace remoting