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

content/renderer/media/audio_input_device.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 "content/renderer/media/audio_input_device.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
@@ skipping 30 matching lines @@
                                    int channels,
                                    double sample_rate,
                                    CaptureCallback* callback,
                                    CaptureEventHandler* event_handler)
     : ScopedLoopObserver(ChildProcess::current()->io_message_loop()),
       callback_(callback),
       event_handler_(event_handler),
       volume_(1.0),
       stream_id_(0),
       session_id_(0),
-      pending_device_ready_(false) {
+      pending_device_ready_(false),
+     agc_is_enabled_(false) {

[tommi (sloooow) - chröme, 2012/03/26 15:26:38]

indent

   filter_ = RenderThreadImpl::current()->audio_input_message_filter();
 #if defined(OS_MACOSX)
   DVLOG(1) << "Using AUDIO_PCM_LOW_LATENCY as input mode on Mac OS X.";
   audio_parameters_.format = AudioParameters::AUDIO_PCM_LOW_LATENCY;
 #elif defined(OS_WIN)
   DVLOG(1) << "Using AUDIO_PCM_LOW_LATENCY as input mode on Windows.";
   audio_parameters_.format = AudioParameters::AUDIO_PCM_LOW_LATENCY;
 #else
   // TODO(henrika): add support for AUDIO_PCM_LOW_LATENCY on Linux as well.
   audio_parameters_.format = AudioParameters::AUDIO_PCM_LINEAR;
@@ skipping 28 matching lines @@
   {
     base::AutoLock auto_lock(audio_thread_lock_);
     audio_thread_.Stop(MessageLoop::current());
   }
 
   message_loop()->PostTask(FROM_HERE,
       base::Bind(&AudioInputDevice::ShutDownOnIOThread, this));
 }
 
 bool AudioInputDevice::SetVolume(double volume) {
-  NOTIMPLEMENTED();
+  if (volume < 0 || volume > 1.0)
+    return false;

[tommi (sloooow) - chröme, 2012/03/26 15:26:38]

NOTREACHED?

+
+  message_loop()->PostTask(FROM_HERE,
+      base::Bind(&AudioInputDevice::SetVolumeOnIOThread, this, volume));
+
+  return true;
+}
+
+bool AudioInputDevice::GetVolume(double* volume) {
+  NOTREACHED();
   return false;
 }
 
-bool AudioInputDevice::GetVolume(double* volume) {
-  NOTIMPLEMENTED();
-  return false;
+void AudioInputDevice::SetAutomaticGainControl(bool enabled) {
+  DVLOG(1) << "SetAutomaticGainControl(enabled=" << enabled << ")";
+  message_loop()->PostTask(FROM_HERE,
+      base::Bind(&AudioInputDevice::SetAutomaticGainControlOnIOThread,
+          this, enabled));
 }
 
 void AudioInputDevice::InitializeOnIOThread() {
   DCHECK(message_loop()->BelongsToCurrentThread());
   // Make sure we don't call Start() more than once.
   DCHECK_EQ(0, stream_id_);
   if (stream_id_)
     return;
 
   stream_id_ = filter_->AddDelegate(this);
   // If |session_id_| is not specified, it will directly create the stream;
   // otherwise it will send a AudioInputHostMsg_StartDevice msg to the browser
   // and create the stream when getting a OnDeviceReady() callback.
   if (!session_id_) {
     Send(new AudioInputHostMsg_CreateStream(
-        stream_id_, audio_parameters_, AudioManagerBase::kDefaultDeviceId));
+        stream_id_, audio_parameters_, AudioManagerBase::kDefaultDeviceId,
+        agc_is_enabled_));
   } else {
     Send(new AudioInputHostMsg_StartDevice(stream_id_, session_id_));
     pending_device_ready_ = true;
   }
 }
 
 void AudioInputDevice::SetSessionIdOnIOThread(int session_id) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   session_id_ = session_id;
 }
 
 void AudioInputDevice::StartOnIOThread() {
   DCHECK(message_loop()->BelongsToCurrentThread());
   if (stream_id_)
     Send(new AudioInputHostMsg_RecordStream(stream_id_));
 }
 
 void AudioInputDevice::ShutDownOnIOThread() {
   DCHECK(message_loop()->BelongsToCurrentThread());
   // NOTE: |completion| may be NULL.
   // Make sure we don't call shutdown more than once.
   if (stream_id_) {
     filter_->RemoveDelegate(stream_id_);
     Send(new AudioInputHostMsg_CloseStream(stream_id_));
 
     stream_id_ = 0;
     session_id_ = 0;
     pending_device_ready_ = false;
+    agc_is_enabled_ = false;
   }
 
   // We can run into an issue where ShutDownOnIOThread is called right after
   // OnStreamCreated is called in cases where Start/Stop are called before we
   // get the OnStreamCreated callback.  To handle that corner case, we call
   // Stop(). In most cases, the thread will already be stopped.
   // Another situation is when the IO thread goes away before Stop() is called
   // in which case, we cannot use the message loop to close the thread handle
   // and can't not rely on the main thread existing either.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   audio_thread_.Stop(NULL);
   audio_callback_.reset();
 }
 
 void AudioInputDevice::SetVolumeOnIOThread(double volume) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   if (stream_id_)
     Send(new AudioInputHostMsg_SetVolume(stream_id_, volume));
 }
 
+void AudioInputDevice::SetAutomaticGainControlOnIOThread(bool enabled) {
+  DCHECK(message_loop()->BelongsToCurrentThread());
+  // The state of the AGC can not be modified while capturing is active.
+  DCHECK_EQ(0, stream_id_);
+  if (stream_id_)
+    return;
+
+  // We simply store the new AGC setting here. This value will be used when
+  // a new stream is initialized and by GetAutomaticGainControl().
+  agc_is_enabled_ = enabled;
+}
+
 void AudioInputDevice::OnStreamCreated(
     base::SharedMemoryHandle handle,
     base::SyncSocket::Handle socket_handle,
     uint32 length) {
   DCHECK(message_loop()->BelongsToCurrentThread());
 #if defined(OS_WIN)
   DCHECK(handle);
   DCHECK(socket_handle);
 #else
   DCHECK_GE(handle.fd, 0);
@@ skipping 77 matching lines @@
   if (!pending_device_ready_)
     return;
 
   // If AudioInputDeviceManager returns an empty string, it means no device
   // is ready for start.
   if (device_id.empty()) {
     filter_->RemoveDelegate(stream_id_);
     stream_id_ = 0;
   } else {
     Send(new AudioInputHostMsg_CreateStream(stream_id_, audio_parameters_,
-                                            device_id));
+                                            device_id, agc_is_enabled_));
   }
 
   pending_device_ready_ = false;
   // Notify the client that the device has been started.
   if (event_handler_)
     event_handler_->OnDeviceStarted(device_id);
 }
 
 void AudioInputDevice::Send(IPC::Message* message) {
   filter_->Send(message);
@@ skipping 15 matching lines @@
 }
 
 AudioInputDevice::AudioThreadCallback::~AudioThreadCallback() {
 }
 
 void AudioInputDevice::AudioThreadCallback::MapSharedMemory() {
   shared_memory_.Map(memory_length_);
 }
 
 void AudioInputDevice::AudioThreadCallback::Process(int pending_data) {
+

[tommi (sloooow) - chröme, 2012/03/26 15:26:38]

remove empty line

+  // The shared memory represents parameters, size of the data buffer and the
+  // actual data buffer containing audio data. Map the memory into this
+  // structure and parse out parameters and data area.
+  AudioInputBuffer* buffer =
+      reinterpret_cast<AudioInputBuffer*>(shared_memory_.memory());
+  uint32 size = buffer->params.size;
+  DCHECK_EQ(size, memory_length_ - sizeof(AudioInputBufferParameters));
+  double volume = buffer->params.volume;
+
   int audio_delay_milliseconds = pending_data / bytes_per_ms_;
-  int16* memory = reinterpret_cast<int16*>(shared_memory_.memory());
+  int16* memory = reinterpret_cast<int16*>(&buffer->audio[0]);
   const size_t number_of_frames = audio_parameters_.samples_per_packet;
   const int bytes_per_sample = sizeof(memory[0]);
 
   // Deinterleave each channel and convert to 32-bit floating-point
   // with nominal range -1.0 -> +1.0.
   for (int channel_index = 0; channel_index < audio_parameters_.channels;
        ++channel_index) {
     media::DeinterleaveAudioChannel(memory,
                                     audio_data_[channel_index],
                                     audio_parameters_.channels,
                                     channel_index,
                                     bytes_per_sample,
                                     number_of_frames);
   }
 
   // Deliver captured data to the client in floating point format
   // and update the audio-delay measurement.
   capture_callback_->Capture(audio_data_, number_of_frames,
-                             audio_delay_milliseconds);
+                             audio_delay_milliseconds, volume);
 }