Adds Analog Gain Control (AGC) to the WebRTC client.

media/audio/win/audio_low_latency_input_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 "media/audio/win/audio_low_latency_input_win.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/win/audio_manager_win.h"
 #include "media/audio/win/avrt_wrapper_win.h"
 
+static const int kMinIntervalBetweenVolumeUpdatesMs = 1000;
+
 using base::win::ScopedComPtr;
 using base::win::ScopedCOMInitializer;
 
 WASAPIAudioInputStream::WASAPIAudioInputStream(
     AudioManagerWin* manager, const AudioParameters& params,
     const std::string& device_id)
     : com_init_(ScopedCOMInitializer::kMTA),
       manager_(manager),
       capture_thread_(NULL),
       opened_(false),
       started_(false),
       endpoint_buffer_size_frames_(0),
       device_id_(device_id),
-      sink_(NULL) {
+      sink_(NULL),
+      volume_(0.0),
+      agc_is_enabled_(0) {
   DCHECK(manager_);
 
   // Load the Avrt DLL if not already loaded. Required to support MMCSS.
   bool avrt_init = avrt::Initialize();
   DCHECK(avrt_init) << "Failed to load the Avrt.dll";
 
   // Set up the desired capture format specified by the client.
   format_.nSamplesPerSec = params.sample_rate;
   format_.wFormatTag = WAVE_FORMAT_PCM;
   format_.wBitsPerSample = params.bits_per_sample;
@@ skipping 147 matching lines @@
   DLOG_IF(ERROR, !opened_) << "Open() has not been called successfully";
   if (!opened_)
     return 0.0;
 
   // The effective volume value is always in the range 0.0 to 1.0, hence
   // we can return a fixed value (=1.0) here.
   return 1.0;
 }
 
 void WASAPIAudioInputStream::SetVolume(double volume) {
+  DVLOG(1) << "SetVolume(volume=" << volume << ")";
   DCHECK(CalledOnValidThread());
   DCHECK(volume <= 1.0 && volume >= 0.0);
 
   DLOG_IF(ERROR, !opened_) << "Open() has not been called successfully";
   if (!opened_)
     return;
 
   // Set a new master volume level. Valid volume levels are in the range
   // 0.0 to 1.0. Ignore volume-change events.
   HRESULT hr = simple_audio_volume_->SetMasterVolume(static_cast<float>(volume),
-                                                     NULL);
+    NULL);

[tommi (sloooow) - chröme, 2012/03/16 13:31:05]

indent

[henrika (OOO until Aug 14), 2012/03/21 10:16:04]

Done.

   DLOG_IF(WARNING, FAILED(hr)) << "Failed to set new input master volume.";
+
+  // We take new volume samples once every second when the AGC is enabled.
+  // To ensure that a new setting has an immediate effect, the new volume
+  // setting is cached here. It will ensure that the next OnData() callback
+  // will contain a new valid volume level. If this approach was not taken,
+  // we could report invalid volume levels to the client for a time period
+  // of up to one second.
+  if (GetAutomaticGainControl()) {
+    volume_ = GetVolume();
+  }
 }
 
 double WASAPIAudioInputStream::GetVolume() {
   DCHECK(CalledOnValidThread());
   DLOG_IF(ERROR, !opened_) << "Open() has not been called successfully";
   if (!opened_)
     return 0.0;
 
   // Retrieve the current volume level. The value is in the range 0.0 to 1.0.
   float level = 0.0f;
   HRESULT hr = simple_audio_volume_->GetMasterVolume(&level);
   DLOG_IF(WARNING, FAILED(hr)) << "Failed to get input master volume.";
 
   return static_cast<double>(level);
 }
 
+void WASAPIAudioInputStream::SetAutomaticGainControl(bool enabled) {

[tommi (sloooow) - chröme, 2012/03/16 13:31:05]

seems like we have a lot of similar or exactly the same code here as for the
output stream. Can't we have that code in one place somehow?

[henrika (OOO until Aug 14), 2012/03/21 10:16:04]

I feel the same way. Let me try to come up with something.

+  base::subtle::Release_Store(&agc_is_enabled_, enabled);
+}
+
+bool WASAPIAudioInputStream::GetAutomaticGainControl() {
+  return (base::subtle::Acquire_Load(&agc_is_enabled_) == 1);
+}
+
 // static
 double WASAPIAudioInputStream::HardwareSampleRate(
     const std::string& device_id) {
   base::win::ScopedCoMem<WAVEFORMATEX> audio_engine_mix_format;
   HRESULT hr = GetMixFormat(device_id, &audio_engine_mix_format);
   if (FAILED(hr))
     return 0.0;
 
   return static_cast<double>(audio_engine_mix_format->nSamplesPerSec);
 }
@@ skipping 149 matching lines @@
           // Derive a delay estimate for the captured audio packet.
           // The value contains two parts (A+B), where A is the delay of the
           // first audio frame in the packet and B is the extra delay
           // contained in any stored data. Unit is in audio frames.
           QueryPerformanceCounter(&now_count);
           double audio_delay_frames =
               ((perf_count_to_100ns_units_ * now_count.QuadPart -
                 first_audio_frame_timestamp) / 10000.0) * ms_to_frame_count_ +
                 buffer_frame_index - num_frames_to_read;
 
+          // Query a new volume level if AGC is enabled and if it is time to
+          // update the old value.
+          if (GetAutomaticGainControl()) {

[tommi (sloooow) - chröme, 2012/03/16 13:31:05]

this code looks the same too

+            base::Time now = base::Time::Now();
+            if ((now - last_volume_update_time_).InMilliseconds() >
+                kMinIntervalBetweenVolumeUpdatesMs) {
+              // Retrieve the current volume level. Range is [0.0,1.0].
+              float level = 0.0f;
+              HRESULT hr = simple_audio_volume_->GetMasterVolume(&level);
+              if (SUCCEEDED(hr))
+                volume_ = static_cast<double>(level);
+              last_volume_update_time_ = now;
+            }
+          }
+
           // Deliver captured data to the registered consumer using a packet
           // size which was specified at construction.
           uint32 delay_frames = static_cast<uint32>(audio_delay_frames + 0.5);
           while (buffer_frame_index >= packet_size_frames_) {
             uint8* audio_data =
                 reinterpret_cast<uint8*>(capture_buffer.get());
 
-            // Deliver data packet and delay estimation to the user.
+            // Deliver data packet, delay estimation and volume level to
+            // the user.
             sink_->OnData(this,
                           audio_data,
                           packet_size_bytes_,
-                          delay_frames * frame_size_);
+                          delay_frames * frame_size_,
+                          volume_);
 
             // Store parts of the recorded data which can't be delivered
             // using the current packet size. The stored section will be used
             // either in the next while-loop iteration or in the next
             // capture event.
             memmove(&capture_buffer[0],
                     &capture_buffer[packet_size_bytes_],
                     (buffer_frame_index - packet_size_frames_) * frame_size_);
 
             buffer_frame_index -= packet_size_frames_;
@@ skipping 204 matching lines @@
                                  audio_capture_client_.ReceiveVoid());
   if (FAILED(hr))
     return hr;
 
   // Obtain a reference to the ISimpleAudioVolume interface which enables
   // us to control the master volume level of an audio session.
   hr = audio_client_->GetService(__uuidof(ISimpleAudioVolume),
                                  simple_audio_volume_.ReceiveVoid());
   return hr;
 }