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

media/audio/audio_input_controller.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/audio_input_controller.h"
 
 #include "base/bind.h"
 #include "base/threading/thread_restrictions.h"
 #include "media/base/limits.h"
 
@@ skipping 10 matching lines @@
 AudioInputController::AudioInputController(EventHandler* handler,
                                            SyncWriter* sync_writer)
     : creator_loop_(base::MessageLoopProxy::current()),
       handler_(handler),
       stream_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(no_data_timer_(FROM_HERE,
           base::TimeDelta::FromSeconds(kTimerResetInterval),
           this,
           &AudioInputController::DoReportNoDataError)),
       state_(kEmpty),
-      sync_writer_(sync_writer) {
+      sync_writer_(sync_writer),
+      max_volume_(0.0) {
   DCHECK(creator_loop_);
 }
 
 AudioInputController::~AudioInputController() {
   DCHECK(kClosed == state_ || kCreated == state_ || kEmpty == state_);
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::Create(
     AudioManager* audio_manager,
@@ skipping 58 matching lines @@
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoRecord, this));
 }
 
 void AudioInputController::Close(const base::Closure& closed_task) {
   DCHECK(!closed_task.is_null());
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoClose, this, closed_task));
 }
 
+void AudioInputController::SetVolume(double volume) {
+  message_loop_->PostTask(FROM_HERE, base::Bind(
+      &AudioInputController::DoSetVolume, this, volume));
+}
+
+void AudioInputController::SetAutomaticGainControl(bool enabled) {
+  message_loop_->PostTask(FROM_HERE, base::Bind(
+      &AudioInputController::DoSetAutomaticGainControl, this, enabled));
+}
+
 void AudioInputController::DoCreate(AudioManager* audio_manager,
                                     const AudioParameters& params,
                                     const std::string& device_id) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   stream_ = audio_manager->MakeAudioInputStream(params, device_id);
 
   if (!stream_) {
     // TODO(satish): Define error types.
     handler_->OnError(this, 0);
@@ skipping 44 matching lines @@
   }
 
   closed_task.Run();
 }
 
 void AudioInputController::DoReportError(int code) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   handler_->OnError(this, code);
 }
 
+void AudioInputController::DoSetVolume(double volume) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK_GE(volume, 0);
+  DCHECK_LE(volume, 1.0);
+
+  if (state_ != kCreated && state_ != kRecording)
+    return;
+
+  // Only ask for the maximum volume at first call and use cached value
+  // for remaining function calls.
+  if (!max_volume_) {
+    max_volume_ = stream_->GetMaxVolume();
+  }
+
+  if (max_volume_ == 0.0) {
+    DLOG(WARNING) << "Failed to access input volume control";
+    return;
+  }
+
+  // Set the stream volume and scale to a range matched to the platform.
+  stream_->SetVolume(max_volume_ * volume);
+}
+
+void AudioInputController::DoSetAutomaticGainControl(bool enabled) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  DCHECK_NE(state_, kRecording);
+
+  // Ensure that the AGC state only can be modified before streaming starts.
+  if (state_ != kCreated || state_ == kRecording)
+    return;
+
+  stream_->SetAutomaticGainControl(enabled);
+}
+
 void AudioInputController::DoReportNoDataError() {
   DCHECK(creator_loop_->BelongsToCurrentThread());
 
   // Error notifications should be sent on the audio-manager thread.
   int code = 0;
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoReportError, this, code));
 }
 
 void AudioInputController::DoResetNoDataTimer() {
   DCHECK(creator_loop_->BelongsToCurrentThread());
   no_data_timer_.Reset();
 }
 
 void AudioInputController::OnData(AudioInputStream* stream, const uint8* data,
-                                  uint32 size, uint32 hardware_delay_bytes) {
+                                  uint32 size, uint32 hardware_delay_bytes,
+                                  double volume) {
   {
     base::AutoLock auto_lock(lock_);
     if (state_ != kRecording)
       return;
   }
 
   creator_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoResetNoDataTimer, this));
 
   // Use SyncSocket if we are in a low-latency mode.
   if (LowLatencyMode()) {
-    sync_writer_->Write(data, size);
+    sync_writer_->Write(data, size, volume);
     sync_writer_->UpdateRecordedBytes(hardware_delay_bytes);
     return;
   }
 
   handler_->OnData(this, data, size);
 }
 
 void AudioInputController::OnClose(AudioInputStream* stream) {
   DVLOG(1) << "AudioInputController::OnClose()";
   // TODO(satish): Sometimes the device driver closes the input stream without
@@ skipping 17 matching lines @@
     stream_->Close();
     stream_ = NULL;
   }
 
   // Should be last in the method, do not touch "this" from here on.
   if (done != NULL)
     done->Signal();
 }
 
 }  // namespace media