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

content/renderer/media/webrtc_audio_device_impl.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/webrtc_audio_device_impl.h"
 
 #include "base/bind.h"
 #include "base/string_util.h"
 #include "base/win/windows_version.h"
 #include "content/renderer/media/audio_hardware.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_util.h"
 
 static const int64 kMillisecondsBetweenProcessCalls = 5000;
+static const double kMaxVolumeLevel = 255.0;
 
 // Supported hardware sample rates for input and output sides.
 #if defined(OS_WIN) || defined(OS_MACOSX)
 // media::GetAudioInput[Output]HardwareSampleRate() asks the audio layer
 // for its current sample rate (set by the user) on Windows and Mac OS X.
 // The listed rates below adds restrictions and WebRtcAudioDeviceImpl::Init()
 // will fail if the user selects any rate outside these ranges.
 static int kValidInputRates[] = {96000, 48000, 44100, 32000, 16000};
 static int kValidOutputRates[] = {96000, 48000, 44100};
 #elif defined(OS_LINUX) || defined(OS_OPENBSD)
@@ skipping 14 matching lines @@
       input_sample_rate_(0),
       output_sample_rate_(0),
       input_delay_ms_(0),
       output_delay_ms_(0),
       last_error_(AudioDeviceModule::kAdmErrNone),
       last_process_time_(base::TimeTicks::Now()),
       session_id_(0),
       bytes_per_sample_(0),
       initialized_(false),
       playing_(false),
-      recording_(false) {
+      recording_(false),
+      agc_is_enabled_(false) {
     DVLOG(1) << "WebRtcAudioDeviceImpl::WebRtcAudioDeviceImpl()";
     DCHECK(RenderThreadImpl::current()) <<
         "WebRtcAudioDeviceImpl must be constructed on the render thread";
 }
 
 WebRtcAudioDeviceImpl::~WebRtcAudioDeviceImpl() {
   DVLOG(1) << "WebRtcAudioDeviceImpl::~WebRtcAudioDeviceImpl()";
   if (playing_)
     StopPlayout();
   if (recording_)
@@ skipping 71 matching lines @@
   }
   return number_of_frames;
 }
 
 void WebRtcAudioDeviceImpl::OnRenderError() {
   DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
   // TODO(henrika): Implement error handling.
   LOG(ERROR) << "OnRenderError()";
 }
 
-void WebRtcAudioDeviceImpl::Capture(
-    const std::vector<float*>& audio_data,
-    size_t number_of_frames,
-    size_t audio_delay_milliseconds) {
+void WebRtcAudioDeviceImpl::Capture(const std::vector<float*>& audio_data,
+                                    size_t number_of_frames,
+                                    size_t audio_delay_milliseconds,
+                                    double volume) {
   DCHECK_LE(number_of_frames, input_buffer_size_);
-
+  DCHECK_LE(volume, 1.0);
   int output_delay_ms = 0;
   {
     base::AutoLock auto_lock(lock_);
     // Store the reported audio delay locally.
     input_delay_ms_ = audio_delay_milliseconds;
     output_delay_ms = output_delay_ms_;
   }
 
   const int channels = audio_data.size();
   DCHECK_LE(channels, input_channels_);
   uint32_t new_mic_level = 0;
 
   // Interleave, scale, and clip input to int16 and store result in
   // a local byte buffer.
   media::InterleaveFloatToInt16(audio_data,
                                 input_buffer_.get(),
                                 number_of_frames);
 
   int samples_per_sec = static_cast<int>(input_sample_rate_);
   if (samples_per_sec == 44100) {
     // Even if the hardware runs at 44.1kHz, we use 44.0 internally.
     samples_per_sec = 44000;
   }
   const int samples_per_10_msec = (samples_per_sec / 100);
   const int bytes_per_10_msec =
       channels * samples_per_10_msec * bytes_per_sample_;
   size_t accumulated_audio_samples = 0;
+  char* audio_byte_buffer = reinterpret_cast<char*>(input_buffer_.get());
 
-  char* audio_byte_buffer = reinterpret_cast<char*>(input_buffer_.get());
+  // Map internal volume range of [0.0, 1.0] into [0, 255] used by the
+  // webrtc::VoiceEngine.
+  uint32_t current_mic_level = static_cast<uint32_t>(volume * kMaxVolumeLevel);
 
   // Write audio samples in blocks of 10 milliseconds to the registered
   // webrtc::AudioTransport sink. Keep writing until our internal byte
   // buffer is empty.
   while (accumulated_audio_samples < number_of_frames) {
-    // Deliver 10ms of recorded PCM audio.
-    // TODO(henrika): add support for analog AGC?
+    // Deliver 10ms of recorded 16-bit linear PCM audio.
     audio_transport_callback_->RecordedDataIsAvailable(
         audio_byte_buffer,
         samples_per_10_msec,
         bytes_per_sample_,
         channels,
         samples_per_sec,
         input_delay_ms_ + output_delay_ms,
-        0,  // clock_drift
-        0,  // current_mic_level
-        new_mic_level);  // not used
+        0,  // TODO(henrika): |clock_drift| parameter is not utilized today.
+        current_mic_level,
+        new_mic_level);
+
     accumulated_audio_samples += samples_per_10_msec;
     audio_byte_buffer += bytes_per_10_msec;
   }
+
+  // The AGC returns a non-zero microphone level if it has been decided

[scherkus (not reviewing), 2012/03/20 13:49:41]

I'm confused -- isn't it the audio_transport_callback_ returning a non-zero mic
level as opposed to the AGC?

[henrika (OOO until Aug 14), 2012/03/21 10:16:04]

The last two parameters in RecordedDataIsAvailable() are:
const WebRtc_UWord32 currentMicLevel, and 
WebRtc_UWord32& newMicLevel.

We use currentMicLevel to provide input from the media layer to the AGC in
WebRTC. The AGC then determines if it is time for a volume update or not
(depends on speech or no speech, if the user has moved the volume slider
manually, level of speech etc. If a new volume shall be set, the output
reference paramterer newMicLevel is set to a non-zero value to indicate "it is
now time for a change".

Let me know if something is still not clear.

+  // that a new level should be set.
+  if (new_mic_level != 0) {
+    // Use IPC and set the new level. Note that, it will take some time
+    // before the new level is effective due to the IPC scheme.
+    // During this time, |current_mic_level| will contain "non-valid" values
+    // and it might reduce the AGC performance. Measurements on Windows 7 have
+    // shown that we might receive old volume levels for one or two callbacks.
+    SetMicrophoneVolume(new_mic_level);
+  }
 }
 
 void WebRtcAudioDeviceImpl::OnCaptureError() {
   DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
   // TODO(henrika): Implement error handling.
   LOG(ERROR) << "OnCaptureError()";
 }
 
 void WebRtcAudioDeviceImpl::OnDeviceStarted(const std::string& device_id) {
   DVLOG(1) << "OnDeviceStarted (device_id=" << device_id << ")";
@@ skipping 464 matching lines @@
   base::AutoLock auto_lock(lock_);
   recording_ = false;
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::Recording() const {
   return recording_;
 }
 
 int32_t WebRtcAudioDeviceImpl::SetAGC(bool enable) {
-  DVLOG(2) << "WARNING: WebRtcAudioDeviceImpl::SetAGC() " << "NOT IMPLEMENTED";
-  return -1;
+  // The most common usage is to set the AGC state before recording starts.
+  // The AudioInputDevice also supports changing the AGC state on the fly,
+  // i.e., it is possible to modify the AGC state while audio streaming is
+  // active.

[scherkus (not reviewing), 2012/03/21 09:21:21]

when you say "most common usage" do you actually mean WebRTC will always set AGC
before recording starts or does it actually depend on some other factor?

I imagine we could simplify some things if we only permitted recording either
with/without AGC enabled (i.e., disallow changing on the fly)

[henrika (OOO until Aug 14), 2012/03/21 10:16:04]

I discussed it with Justin and it was OK to add such a restriction. I will
simplify and also remove usage of base::subtle in the media layer.

+  audio_input_device_->SetAutomaticGainControl(enable);
+  agc_is_enabled_ = enable;
+  return 0;
 }
 
 bool WebRtcAudioDeviceImpl::AGC() const {
-  DVLOG(2) << "WARNING: WebRtcAudioDeviceImpl::AGC() " << "NOT IMPLEMENTED";
-  return false;
+  // To reduce the usage of IPC messages, an internal AGC state is used.
+  // TODO(henrika): investigate if there is a need for a "deeper" getter.
+  return agc_is_enabled_;
 }
 
 int32_t WebRtcAudioDeviceImpl::SetWaveOutVolume(uint16_t volume_left,
                                                 uint16_t volume_right) {
   NOTIMPLEMENTED();
   return -1;
 }
 int32_t WebRtcAudioDeviceImpl::WaveOutVolume(
     uint16_t* volume_left,
     uint16_t* volume_right) const {
@@ skipping 52 matching lines @@
 int32_t WebRtcAudioDeviceImpl::SpeakerVolume(uint32_t* volume) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::MaxSpeakerVolume(uint32_t* max_volume) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
-int32_t WebRtcAudioDeviceImpl::MinSpeakerVolume(
-    uint32_t* min_volume) const {
+int32_t WebRtcAudioDeviceImpl::MinSpeakerVolume(uint32_t* min_volume) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::SpeakerVolumeStepSize(
     uint16_t* step_size) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::MicrophoneVolumeIsAvailable(bool* available) {
   NOTIMPLEMENTED();
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::SetMicrophoneVolume(uint32_t volume) {
-  NOTIMPLEMENTED();
+  DVLOG(1) << "SetMicrophoneVolume(" << volume << ")";
+  if (volume > kMaxVolumeLevel)
+    return -1;
+
+  // WebRTC uses a range of [0, 255] to represent the level of the microphone
+  // volume. The IPC channel between the renderer and browser process works
+  // with doubles in the [0.0, 1.0] range and we have to compensate for that.
+  double normalized_volume = static_cast<double>(volume / kMaxVolumeLevel);

[tommi (sloooow) - chröme, 2012/03/16 13:31:05]

is the cast needed?

[henrika (OOO until Aug 14), 2012/03/21 10:16:04]

Good question. I don't think is required for fundamental types but implicit
casting will most likely be enough. Do you find it disturbing? I think it is OK
as is.

+  audio_input_device_->SetVolume(normalized_volume);
+  return 0;
+}
+
+int32_t WebRtcAudioDeviceImpl::MicrophoneVolume(uint32_t* volume) const {
+  // The microphone level is fed to this class using the Capture() callback
+  // and this external API should not be used. Additional IPC messages are
+  // required if support for this API is ever needed.
+  NOTREACHED();
   return -1;
 }
 
-int32_t WebRtcAudioDeviceImpl::MicrophoneVolume(uint32_t* volume) const {
-  NOTIMPLEMENTED();
-  return -1;
+int32_t WebRtcAudioDeviceImpl::MaxMicrophoneVolume(uint32_t* max_volume) const {
+  *max_volume = kMaxVolumeLevel;
+  return 0;
 }
 
-int32_t WebRtcAudioDeviceImpl::MaxMicrophoneVolume(
-    uint32_t* max_volume) const {
-  DVLOG(2) << "WARNING: WebRtcAudioDeviceImpl::MaxMicrophoneVolume() "
-           << "NOT IMPLEMENTED";
-  return -1;
-}
-
-int32_t WebRtcAudioDeviceImpl::MinMicrophoneVolume(
-    uint32_t* min_volume) const {
-  DVLOG(2) << "WARNING: WebRtcAudioDeviceImpl::MinMicrophoneVolume() "
-           << "NOT IMPLEMENTED";
-  return -1;
+int32_t WebRtcAudioDeviceImpl::MinMicrophoneVolume(uint32_t* min_volume) const {
+  *min_volume = 0;
+  return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::MicrophoneVolumeStepSize(
     uint16_t* step_size) const {
-  NOTIMPLEMENTED();
+  NOTREACHED();

[tommi (sloooow) - chröme, 2012/03/16 13:31:05]

A comment on why we never expect this to be called?

[henrika (OOO until Aug 14), 2012/03/21 10:16:04]

Good question. It is a method that have caused us many issues in the past since
very few platforms support it, and those who do does it in slightly different
ways. Basically, it is only useful for unit tests where one wants to sweep the
volume and know for sure that a change does in fact have an effect.

   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::SpeakerMuteIsAvailable(bool* available) {
   NOTIMPLEMENTED();
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::SetSpeakerMute(bool enable) {
   NOTIMPLEMENTED();
@@ skipping 177 matching lines @@
 }
 
 int32_t WebRtcAudioDeviceImpl::GetLoudspeakerStatus(bool* enabled) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
 void WebRtcAudioDeviceImpl::SetSessionId(int session_id) {
   session_id_ = session_id;
 }