Improved AGC update scheme for the audio backend in Chrome

media/audio/pulse/pulse_input.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/pulse/pulse_input.h"
 
 #include <pulse/pulseaudio.h>
 
 #include "base/logging.h"
 #include "media/audio/pulse/audio_manager_pulse.h"
@@ skipping 48 matching lines @@
 
 void PulseAudioInputStream::Start(AudioInputCallback* callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(callback);
   DCHECK(handle_);
   AutoPulseLock auto_lock(pa_mainloop_);
 
   if (stream_started_)
     return;
 
+  StartAgc();
+
   // Clean up the old buffer.
   pa_stream_drop(handle_);
   buffer_->Clear();
 
   // Start the streaming.
   callback_ = callback;
   pa_stream_set_read_callback(handle_, &ReadCallback, this);
   pa_stream_readable_size(handle_);
   stream_started_ = true;
 
   pa_operation* operation = pa_stream_cork(handle_, 0, NULL, NULL);
   WaitForOperationCompletion(pa_mainloop_, operation);
 }
 
 void PulseAudioInputStream::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
   AutoPulseLock auto_lock(pa_mainloop_);
   if (!stream_started_)
     return;
 
+  StopAgc();
+
   // Set the flag to false to stop filling new data to soundcard.
   stream_started_ = false;
 
   pa_operation* operation = pa_stream_flush(handle_,
                                             &pulse::StreamSuccessCallback,
                                             pa_mainloop_);
   WaitForOperationCompletion(pa_mainloop_, operation);
 
   // Stop the stream.
   pa_stream_set_read_callback(handle_, NULL, NULL);
@@ skipping 140 matching lines @@
   pa_threaded_mainloop_signal(stream->pa_mainloop_, 0);
 }
 
 void PulseAudioInputStream::ReadData() {
   uint32 hardware_delay = pulse::GetHardwareLatencyInBytes(
       handle_, params_.sample_rate(), params_.GetBytesPerFrame());
 
   // 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() will trigger a callback to asynchronously update the
-  // |volume_|, we disregard the |normalized_volume| from QueryAgcVolume()
+  // We disregard the |normalized_volume| from GetAgcVolume()
   // and use the value calculated by |volume_|.
   double normalized_volume = 0.0;
-  QueryAgcVolume(&normalized_volume);
+  GetAgcVolume(&normalized_volume);
   normalized_volume = volume_ / GetMaxVolume();
 
   do {
     size_t length = 0;
     const void* data = NULL;
     pa_stream_peek(handle_, &data, &length);
     if (!data || length == 0)
       break;
 
     buffer_->Append(reinterpret_cast<const uint8*>(data), length);
@@ skipping 15 matching lines @@
     // input side.
     DVLOG(1) << "OnData is being called consecutively, sleep 5ms to "
              << "wait until render consumes the data";
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(5));
   }
 
   pa_threaded_mainloop_signal(pa_mainloop_, 0);
 }
 
 }  // namespace media