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"
@@ skipping 174 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);
+  DCHECK_GE(volume, 0.0);
+  DCHECK_LE(volume, 1.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);
   DLOG_IF(WARNING, FAILED(hr)) << "Failed to set new input master volume.";
+
+  // Update the AGC volume level based on the last setting above. Note that,
+  // the volume-level resolution is not infinite and it is therefore not
+  // possible to assume that the volume provided as input parameter can be
+  // used directly. Instead, a new query to the audio hardware is required.
+  // This method does nothing if AGC is disabled.
+  UpdateAgcVolume();
 }
 
 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);
@@ skipping 95 matching lines @@
   //    each event.
   size_t buffer_frame_index = 0;
   size_t capture_buffer_size = std::max(
       2 * endpoint_buffer_size_frames_ * frame_size_,
       2 * packet_size_frames_ * frame_size_);
   scoped_array<uint8> capture_buffer(new uint8[capture_buffer_size]);
 
   LARGE_INTEGER now_count;
   bool recording = true;
   bool error = false;
+  double volume = GetVolume();
   HANDLE wait_array[2] = {stop_capture_event_, audio_samples_ready_event_};
 
   while (recording && !error) {
     HRESULT hr = S_FALSE;
 
     // Wait for a close-down event or a new capture event.
     DWORD wait_result = WaitForMultipleObjects(2, wait_array, FALSE, INFINITE);
     switch (wait_result) {
       case WAIT_FAILED:
         error = true;
@@ skipping 46 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;
 
+          // Update the AGC volume level once every second. Note that,
+          // |volume| is also updated each time SetVolume() is called
+          // through IPC by the render-side AGC.
+          QueryAgcVolume(&volume);
+
           // 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;
 }