Added a kEchoCancellation constraint to turn off the audio processing.

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 "base/metrics/field_trial.h"
 #include "base/metrics/histogram.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 "content/renderer/media/webrtc_audio_device_impl.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"
 #include "third_party/webrtc/modules/audio_processing/typing_detection.h"
 
 namespace content {
 
 namespace {
 
 using webrtc::AudioProcessing;
-using webrtc::MediaConstraintsInterface;
 
 #if defined(OS_ANDROID)
 const int kAudioProcessingSampleRate = 16000;
 #else
 const int kAudioProcessingSampleRate = 32000;
 #endif
 const int kAudioProcessingNumberOfChannels = 1;
 const AudioProcessing::ChannelLayout kAudioProcessingChannelLayout =
     AudioProcessing::kMono;
 
@@ skipping 121 matching lines @@
 bool MediaStreamAudioProcessor::IsAudioTrackProcessingEnabled() {
   const std::string group_name =
       base::FieldTrialList::FindFullName("MediaStreamAudioTrackProcessing");
   return group_name == "Enabled" || CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableAudioTrackProcessing);
 }
 
 MediaStreamAudioProcessor::MediaStreamAudioProcessor(
     const blink::WebMediaConstraints& constraints,
     int effects,
-    MediaStreamType type,
     WebRtcPlayoutDataSource* playout_data_source)
     : render_delay_ms_(0),
       playout_data_source_(playout_data_source),
       audio_mirroring_(false),
       typing_detected_(false) {
   capture_thread_checker_.DetachFromThread();
   render_thread_checker_.DetachFromThread();
-  InitializeAudioProcessingModule(constraints, effects, type);
+  InitializeAudioProcessingModule(constraints, effects);
 }
 
 MediaStreamAudioProcessor::~MediaStreamAudioProcessor() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   StopAudioProcessing();
 }
 
 void MediaStreamAudioProcessor::OnCaptureFormatChanged(
     const media::AudioParameters& source_params) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
@@ skipping 90 matching lines @@
   render_converter_.reset();
 }
 
 void MediaStreamAudioProcessor::GetStats(AudioProcessorStats* stats) {
   stats->typing_noise_detected =
       (base::subtle::Acquire_Load(&typing_detected_) != false);
   GetAecStats(audio_processing_.get(), stats);
 }
 
 void MediaStreamAudioProcessor::InitializeAudioProcessingModule(
-    const blink::WebMediaConstraints& constraints, int effects,
-    MediaStreamType type) {
+    const blink::WebMediaConstraints& constraints, int effects) {
   DCHECK(!audio_processing_);
 
-  RTCMediaConstraints native_constraints(constraints);
+  MediaAudioConstraints audio_constraints(constraints, effects);
 
   // Audio mirroring can be enabled even though audio processing is otherwise
   // disabled.
-  audio_mirroring_ = GetPropertyFromConstraints(
-      &native_constraints, webrtc::MediaConstraintsInterface::kAudioMirroring);
+  audio_mirroring_ = audio_constraints.GetProperty(
+      MediaAudioConstraints::kGoogAudioMirroring);
 
   if (!IsAudioTrackProcessingEnabled()) {
     RecordProcessingState(AUDIO_PROCESSING_IN_WEBRTC);
     return;
   }
 
-  // Only apply the fixed constraints for gUM of MEDIA_DEVICE_AUDIO_CAPTURE.
-  DCHECK(IsAudioMediaType(type));
-  if (type == MEDIA_DEVICE_AUDIO_CAPTURE)
-    ApplyFixedAudioConstraints(&native_constraints);
-
-  if (effects & media::AudioParameters::ECHO_CANCELLER) {
-    // If platform echo canceller is enabled, disable the software AEC.
-    native_constraints.AddMandatory(
-        MediaConstraintsInterface::kEchoCancellation,
-        MediaConstraintsInterface::kValueFalse, true);
+  // |kEchoCancellation| is used as a master control on enabling/disabling
+  // the audio processing.
+  // If |kEchoCancellation| is specified in |audio_constraints|, it will use
+  // the defined value there, otherwise use the default value defined by
+  // kDefaultAudioConstraints in media_stream_audio_processor_options.cc.
+  const bool echo_cancellation = audio_constraints.GetEchoCancellationProperty(
+      MediaAudioConstraints::kEchoCancellation);

[tommi (sloooow) - chröme, 2014/04/30 10:58:44]

Here I was thinking that GetEchoCancellationProperty() would not take any
arguments but would handle both kEchoCancellation and kGoogEchoCancellation
correctly internally.  This code would not need a goog_aec variable at all and
no special checks for it since that would all be done by
GetEchoCancellationProperty.

[no longer working on chromium, 2014/05/02 12:24:02]

I think Andrew had already asked similar questions and I had answered it, I
copied the comments below so it will be easier for you. Also to point out the
problem with your proposal: our client need to support kEchoCancellation before
we can remove goog_aec variable, otherwise it will break the music mode. And I
have a relevant TODO 4 lines below.
ajm:
me:
ajm:

[tommi (sloooow) - chröme, 2014/05/03 10:26:28]

Would we still have that problem if GetEchoCancellation implemented the
following algorithm (pseudo code):

bool aec, goog_aec;
bool explicitly_set = GetProperty(kEchoCancellation, &aec);
if (!explicitly_set) {
  explicitly_set = GetProperty(kGoogEchoCancellation, &goog_aec);
  aec = !explicitly_set || goog_aec;
}

return aec;

[no longer working on chromium, 2014/05/05 12:55:56]

nit, tab capture needs a "false" as value if explicitly_set is false here, so
you might mean:
if  (!explicitly_set) {
  if (tab capture)
    aec = false;
  else
    aec = true;
} else
  aec = goog_aec;
AFAIK, there one conner case that prevents us doing this:
# It also turns kGoogEchoCancellation into a master control for audio
processing.
If kEchoCancellation is not explicitly set, kGoogEchoCancellation is explicitly
set to false, this algorithm returns a false as aec, which will turn off the
audio processing even though users might set other goog* constraints to true.

btw, it is a good algorithm.

[tommi (sloooow) - chröme, 2014/05/05 13:58:13]

I don't think echo cancellation applies to tab capture?

The standard echo cancellation constraint should be a master switch in the
absense of other constraints.
If e.g. hpf is enabled, audio processing is required.

+#if defined(OS_IOS)
+  // On iOS, VPIO provides built-in AEC.
+  const bool goog_aec = false;
+#else
+  // TODO(xians): goog_aec should just be echo_cancellation.
+  const bool goog_aec = audio_constraints.GetEchoCancellationProperty(
+      MediaAudioConstraints::kGoogEchoCancellation);
+#endif
+  if (!echo_cancellation) {
+    RecordProcessingState(AUDIO_PROCESSING_DISABLED);
+    return;
   }
 
 #if defined(OS_IOS)
-  // On iOS, VPIO provides built-in AEC and AGC.
-  const bool enable_aec = false;
-  const bool enable_agc = false;
+  // On iOS, VPIO provides built-in AGC.
+  const bool goog_agc = false;
 #else
-  const bool enable_aec = GetPropertyFromConstraints(
-      &native_constraints, MediaConstraintsInterface::kEchoCancellation);
-  const bool enable_agc = GetPropertyFromConstraints(
-      &native_constraints, webrtc::MediaConstraintsInterface::kAutoGainControl);
+  const bool goog_agc = audio_constraints.GetProperty(
+      MediaAudioConstraints::kGoogAutoGainControl);
 #endif
 
 #if defined(OS_IOS) || defined(OS_ANDROID)
-  const bool enable_experimental_aec = false;
-  const bool enable_typing_detection = false;
+  const bool goog_experimental_aec = false;
+  const bool goog_typing_detection = false;
 #else
-  const bool enable_experimental_aec = GetPropertyFromConstraints(
-      &native_constraints,
-      MediaConstraintsInterface::kExperimentalEchoCancellation);
-  const bool enable_typing_detection = GetPropertyFromConstraints(
-      &native_constraints, MediaConstraintsInterface::kTypingNoiseDetection);
+  const bool goog_experimental_aec = audio_constraints.GetProperty(
+      MediaAudioConstraints::kGoogExperimentalEchoCancellation);
+  const bool goog_typing_detection = audio_constraints.GetProperty(
+      MediaAudioConstraints::kGoogTypingNoiseDetection);
 #endif
 
-  const bool enable_ns = GetPropertyFromConstraints(
-      &native_constraints, MediaConstraintsInterface::kNoiseSuppression);
-  const bool enable_experimental_ns = GetPropertyFromConstraints(
-        &native_constraints,
-        MediaConstraintsInterface::kExperimentalNoiseSuppression);
-  const bool enable_high_pass_filter = GetPropertyFromConstraints(
-      &native_constraints, MediaConstraintsInterface::kHighpassFilter);
+  const bool goog_ns = audio_constraints.GetProperty(
+      MediaAudioConstraints::kGoogNoiseSuppression);
+  const bool goog_experimental_ns = audio_constraints.GetProperty(
+      MediaAudioConstraints::kGoogExperimentalNoiseSuppression);
+ const bool goog_high_pass_filter = audio_constraints.GetProperty(
+     MediaAudioConstraints::kGoogHighpassFilter);
 
-  // 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_agc &&
-      !enable_experimental_ns) {
+  // Return immediately if no goog constraint is enabled.
+  if (!goog_aec && !goog_experimental_aec && !goog_ns &&
+      !goog_high_pass_filter && !goog_typing_detection &&
+      !goog_agc && !goog_experimental_ns) {
     RecordProcessingState(AUDIO_PROCESSING_DISABLED);
     return;
   }
 
   // Create and configure the webrtc::AudioProcessing.
   audio_processing_.reset(webrtc::AudioProcessing::Create());
   CHECK_EQ(0, audio_processing_->Initialize(kAudioProcessingSampleRate,
                                             kAudioProcessingSampleRate,
                                             kAudioProcessingSampleRate,
                                             kAudioProcessingChannelLayout,
                                             kAudioProcessingChannelLayout,
                                             kAudioProcessingChannelLayout));
 
   // Enable the audio processing components.
-  if (enable_aec) {
+  if (goog_aec) {
     EnableEchoCancellation(audio_processing_.get());
-    if (enable_experimental_aec)
+
+    if (goog_experimental_aec)
       EnableExperimentalEchoCancellation(audio_processing_.get());
 
     if (playout_data_source_)
       playout_data_source_->AddPlayoutSink(this);
   }
 
-  if (enable_ns)
+  if (goog_ns)
     EnableNoiseSuppression(audio_processing_.get());
 
-  if (enable_experimental_ns)
+  if (goog_experimental_ns)
     EnableExperimentalNoiseSuppression(audio_processing_.get());
 
-  if (enable_high_pass_filter)
+  if (goog_high_pass_filter)
     EnableHighPassFilter(audio_processing_.get());
 
-  if (enable_typing_detection) {
+  if (goog_typing_detection) {
     // TODO(xians): Remove this |typing_detector_| after the typing suppression
     // is enabled by default.
     typing_detector_.reset(new webrtc::TypingDetection());
     EnableTypingDetection(audio_processing_.get(), typing_detector_.get());
   }
 
-  if (enable_agc)
+  if (goog_agc)
     EnableAutomaticGainControl(audio_processing_.get());
 
   RecordProcessingState(AUDIO_PROCESSING_ENABLED);
 }
 
 void MediaStreamAudioProcessor::InitializeCaptureConverter(
     const media::AudioParameters& source_params) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(source_params.IsValid());
 
@@ skipping 112 matching lines @@
 
   StopAecDump();
 
   if (playout_data_source_)
     playout_data_source_->RemovePlayoutSink(this);
 
   audio_processing_.reset();
 }
 
 }  // namespace content