Improved AGC update scheme for the audio backend in Chrome

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 109 matching lines @@
   DCHECK(callback);
   DLOG_IF(ERROR, !opened_) << "Open() has not been called successfully";
   if (!opened_)
     return;
 
   if (started_)
     return;
 
   sink_ = callback;
 
+  // Starts periodic AGC microphone measurements if the AGC has been enabled
+  // using SetAutomaticGainControl().
+  StartAgc();
+
   // Create and start the thread that will drive the capturing by waiting for
   // capture events.
   capture_thread_ =
       new base::DelegateSimpleThread(this, "wasapi_capture_thread");
   capture_thread_->Start();
 
   // Start streaming data between the endpoint buffer and the audio engine.
   HRESULT hr = audio_client_->Start();
   DLOG_IF(ERROR, FAILED(hr)) << "Failed to start input streaming.";
 
   started_ = SUCCEEDED(hr);
 }
 
 void WASAPIAudioInputStream::Stop() {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "WASAPIAudioInputStream::Stop()";
   if (!started_)
     return;
 
+  // Stops periodic AGC microphone measurements.
+  StopAgc();
+
   // Shut down the capture thread.
   if (stop_capture_event_.IsValid()) {
     SetEvent(stop_capture_event_.Get());
   }
 
   // Stop the input audio streaming.
   HRESULT hr = audio_client_->Stop();
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to stop input streaming.";
   }
@@ skipping 221 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);
+          // Get a cached AGC volume level which is updated once every second
+          // on the audio manager thread. Note that, |volume| is also updated
+          // each time SetVolume() is called through IPC by the render-side AGC.
+          GetAgcVolume(&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, delay estimation and volume level to
             // the user.
@@ skipping 221 matching lines @@
     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;
 }
 
 }  // namespace media