Wire up AGC to the MediaStreamAudioProcessor

content/renderer/media/media_stream_audio_processor.cc

 // Copyright 2013 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/media_stream_audio_processor.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/media/media_stream_audio_processor_options.h"
 #include "content/renderer/media/rtc_media_constraints.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_converter.h"
 #include "media/base/audio_fifo.h"
 #include "media/base/channel_layout.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediaconstraintsinterface.h"
 
 namespace content {
 
 namespace {
 
 using webrtc::AudioProcessing;
 using webrtc::MediaConstraintsInterface;
 
-#if defined(ANDROID)
+#if defined(OS_ANDROID)
 const int kAudioProcessingSampleRate = 16000;
 #else
 const int kAudioProcessingSampleRate = 32000;
 #endif
 const int kAudioProcessingNumberOfChannel = 1;
 
 const int kMaxNumberOfBuffersInFifo = 2;
 
 }  // namespace
 
@@ skipping 98 matching lines @@
   // Handles mixing and resampling between input and output parameters.
   media::AudioConverter audio_converter_;
   scoped_ptr<media::AudioBus> audio_wrapper_;
   scoped_ptr<media::AudioFifo> fifo_;
 };
 
 MediaStreamAudioProcessor::MediaStreamAudioProcessor(
     const media::AudioParameters& source_params,
     const blink::WebMediaConstraints& constraints,
     int effects)
-    : render_delay_ms_(0) {
+    : render_delay_ms_(0),
+      audio_mirroring_(false) {
   capture_thread_checker_.DetachFromThread();
   render_thread_checker_.DetachFromThread();
   InitializeAudioProcessingModule(constraints, effects);
   InitializeCaptureConverter(source_params);
 }
 
 MediaStreamAudioProcessor::~MediaStreamAudioProcessor() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   StopAudioProcessing();
 }
@@ skipping 28 matching lines @@
   render_data_bus_->FromInterleaved(render_audio,
                                     render_data_bus_->frames(),
                                     sizeof(render_audio[0]));
   render_converter_->Push(render_data_bus_.get());
   while (render_converter_->Convert(&render_frame_))
     audio_processing_->AnalyzeReverseStream(&render_frame_);
 }
 
 bool MediaStreamAudioProcessor::ProcessAndConsumeData(
     base::TimeDelta capture_delay, int volume, bool key_pressed,
-    int16** out) {
+    int* new_volume, int16** out) {
   DCHECK(capture_thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("audio",
                "MediaStreamAudioProcessor::ProcessAndConsumeData");
+  *new_volume = 0;

[tommi (sloooow) - chröme, 2014/01/24 12:41:22]

Is it correct to do this here and not below the Convert() check?

A rule of thumb I like to follow is that if a method returns failure, it should
not have modified any of the output parameters.

[no longer working on chromium, 2014/01/24 12:46:53]

Right, actually the new_volume won't be used if the method returns false. So I
removed the setter here.

 
   if (!capture_converter_->Convert(&capture_frame_))
     return false;
 
-  ProcessData(&capture_frame_, capture_delay, volume, key_pressed);
+  *new_volume = ProcessData(&capture_frame_, capture_delay, volume,
+                            key_pressed);
   *out = capture_frame_.data_;
 
   return true;
 }
 
 const media::AudioParameters& MediaStreamAudioProcessor::InputFormat() const {
   return capture_converter_->source_parameters();
 }
 
 const media::AudioParameters& MediaStreamAudioProcessor::OutputFormat() const {
   return capture_converter_->sink_parameters();
 }
 
 void MediaStreamAudioProcessor::InitializeAudioProcessingModule(
     const blink::WebMediaConstraints& constraints, int effects) {
   DCHECK(!audio_processing_);
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAudioTrackProcessing)) {
     return;
   }
 
   RTCMediaConstraints native_constraints(constraints);
   ApplyFixedAudioConstraints(&native_constraints);
   if (effects & media::AudioParameters::ECHO_CANCELLER) {
-    // If platform echo cancellator is enabled, disable the software AEC.
+    // If platform echo canceller is enabled, disable the software AEC.
     native_constraints.AddMandatory(
         MediaConstraintsInterface::kEchoCancellation,
         MediaConstraintsInterface::kValueFalse, true);
   }
 
+#if defined(OS_IOS)
+  // On iOS, VPIO provides built-in AEC and AGC.
+  const bool enable_aec = false;
+  const bool enable_agc = false;
+#else
   const bool enable_aec = GetPropertyFromConstraints(
       &native_constraints, MediaConstraintsInterface::kEchoCancellation);
-  const bool enable_ns = GetPropertyFromConstraints(
-      &native_constraints, MediaConstraintsInterface::kNoiseSuppression);
-  const bool enable_high_pass_filter = GetPropertyFromConstraints(
-      &native_constraints, MediaConstraintsInterface::kHighpassFilter);
-#if defined(IOS) || defined(ANDROID)
+  const bool enable_agc = GetPropertyFromConstraints(
+      &native_constraints, webrtc::MediaConstraintsInterface::kAutoGainControl);
+#endif
+
+#if defined(OS_IOS) || defined(OS_ANDROID)
   const bool enable_experimental_aec = false;
   const bool enable_typing_detection = false;
 #else
   const bool enable_experimental_aec = GetPropertyFromConstraints(
       &native_constraints,
       MediaConstraintsInterface::kExperimentalEchoCancellation);
   const bool enable_typing_detection = GetPropertyFromConstraints(
       &native_constraints, MediaConstraintsInterface::kTypingNoiseDetection);
 #endif
 
+  const bool enable_ns = GetPropertyFromConstraints(
+      &native_constraints, MediaConstraintsInterface::kNoiseSuppression);
+  const bool enable_high_pass_filter = GetPropertyFromConstraints(
+      &native_constraints, MediaConstraintsInterface::kHighpassFilter);
+
+  audio_mirroring_ = GetPropertyFromConstraints(
+      &native_constraints, webrtc::MediaConstraintsInterface::kAudioMirroring);
+
   // Return immediately if no audio processing component is enabled.
   if (!enable_aec && !enable_experimental_aec && !enable_ns &&
-      !enable_high_pass_filter && !enable_typing_detection) {
+      !enable_high_pass_filter && !enable_typing_detection && !enable_agc) {
     return;
   }
 
   // Create and configure the webrtc::AudioProcessing.
   audio_processing_.reset(webrtc::AudioProcessing::Create(0));
 
   // Enable the audio processing components.
   if (enable_aec) {
     EnableEchoCancellation(audio_processing_.get());
     if (enable_experimental_aec)
       EnableExperimentalEchoCancellation(audio_processing_.get());
   }
 
   if (enable_ns)
     EnableNoiseSuppression(audio_processing_.get());
 
   if (enable_high_pass_filter)
     EnableHighPassFilter(audio_processing_.get());
 
   if (enable_typing_detection)
     EnableTypingDetection(audio_processing_.get());
 
+  if (enable_agc)
+    EnableAutomaticGainControl(audio_processing_.get());
 
   // Configure the audio format the audio processing is running on. This
   // has to be done after all the needed components are enabled.
   CHECK_EQ(audio_processing_->set_sample_rate_hz(kAudioProcessingSampleRate),
            0);
   CHECK_EQ(audio_processing_->set_num_channels(kAudioProcessingNumberOfChannel,
                                                kAudioProcessingNumberOfChannel),
            0);
 }
 
@@ skipping 49 matching lines @@
   media::AudioParameters sink_params(
       media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
       media::CHANNEL_LAYOUT_MONO, kAudioProcessingSampleRate, 16,
       kAudioProcessingSampleRate / 100);
   render_converter_.reset(
       new MediaStreamAudioConverter(source_params, sink_params));
   render_data_bus_ = media::AudioBus::Create(number_of_channels,
                                              frames_per_buffer);
 }
 
-void MediaStreamAudioProcessor::ProcessData(webrtc::AudioFrame* audio_frame,
-                                            base::TimeDelta capture_delay,
-                                            int volume,
-                                            bool key_pressed) {
+int MediaStreamAudioProcessor::ProcessData(webrtc::AudioFrame* audio_frame,
+                                           base::TimeDelta capture_delay,
+                                           int volume,
+                                           bool key_pressed) {
   DCHECK(capture_thread_checker_.CalledOnValidThread());
   if (!audio_processing_)
-    return;
+    return 0;
 
-  TRACE_EVENT0("audio", "MediaStreamAudioProcessor::Process10MsData");
+  TRACE_EVENT0("audio", "MediaStreamAudioProcessor::ProcessData");
   DCHECK_EQ(audio_processing_->sample_rate_hz(),
             capture_converter_->sink_parameters().sample_rate());
   DCHECK_EQ(audio_processing_->num_input_channels(),
             capture_converter_->sink_parameters().channels());
   DCHECK_EQ(audio_processing_->num_output_channels(),
             capture_converter_->sink_parameters().channels());
 
   base::subtle::Atomic32 render_delay_ms =
       base::subtle::Acquire_Load(&render_delay_ms_);
   int64 capture_delay_ms = capture_delay.InMilliseconds();
   DCHECK_LT(capture_delay_ms,
             std::numeric_limits<base::subtle::Atomic32>::max());
   int total_delay_ms =  capture_delay_ms + render_delay_ms;
-  if (total_delay_ms > 1000) {
+  if (total_delay_ms > 300) {
     LOG(WARNING) << "Large audio delay, capture delay: " << capture_delay_ms
                  << "ms; render delay: " << render_delay_ms << "ms";
   }
 
   audio_processing_->set_stream_delay_ms(total_delay_ms);
   webrtc::GainControl* agc = audio_processing_->gain_control();
   int err = agc->set_stream_analog_level(volume);
   DCHECK_EQ(err, 0) << "set_stream_analog_level() error: " << err;
   err = audio_processing_->ProcessStream(audio_frame);
   DCHECK_EQ(err, 0) << "ProcessStream() error: " << err;
 
-  // TODO(xians): Add support for AGC, typing detection, audio level
-  // calculation, stereo swapping.
+  // TODO(xians): Add support for typing detection, audio level calculation.
+
+  if (audio_mirroring_ && audio_frame->num_channels_ == 2) {
+    // TODO(xians): Swap the stereo channels after switching to media::AudioBus.
+  }
+
+  // Return 0 if the volume has not been changed, otherwise return the new
+  // volume.
+  return (agc->stream_analog_level() == volume) ?
+      0 : agc->stream_analog_level();
 }
 
 void MediaStreamAudioProcessor::StopAudioProcessing() {
   if (!audio_processing_.get())
     return;
 
   audio_processing_.reset();
 }
 
 }  // namespace content