Added a kEchoCancellation constraint to turn off the audio processing.

content/renderer/media/media_stream_audio_processor_options.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_options.h"
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/media/media_stream_options.h"
+#include "content/renderer/media/media_stream_constraints_util.h"
 #include "content/renderer/media/rtc_media_constraints.h"
 #include "media/audio/audio_parameters.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/include/audio_processing.h"
 #include "third_party/webrtc/modules/audio_processing/typing_detection.h"
 
 namespace content {
 
+const char MediaAudioConstraints::kEchoCancellation[] = "echoCancellation";
+const char MediaAudioConstraints::kGoogEchoCancellation[] =
+    "googEchoCancellation";
+const char MediaAudioConstraints::kGoogExperimentalEchoCancellation[] =
+    "googEchoCancellation2";
+const char MediaAudioConstraints::kGoogAutoGainControl[] =
+    "googAutoGainControl";
+const char MediaAudioConstraints::kGoogExperimentalAutoGainControl[] =
+    "googAutoGainControl2";
+const char MediaAudioConstraints::kGoogNoiseSuppression[] =
+    "googNoiseSuppression";
+const char MediaAudioConstraints::kGoogExperimentalNoiseSuppression[] =
+    "googNoiseSuppression2";
+const char MediaAudioConstraints::kGoogHighpassFilter[] = "googHighpassFilter";
+const char MediaAudioConstraints::kGoogTypingNoiseDetection[] =
+    "googTypingNoiseDetection";
+const char MediaAudioConstraints::kGoogAudioMirroring[] = "googAudioMirroring";
+
 namespace {
 
+// Constraints keys for http://dev.w3.org/2011/webrtc/editor/getusermedia.html.
+const char kSourceId[] = "sourceId";

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

Isn't this also defined elsewhere?
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/m...

Would be good to only have it in one place if possible and since this isn't
audio specific (or video specific either) maybe we should think about moving all
these constants into a specific source file?  If you agree, I'm fine with
putting down a todo here (for me or you) to do that cleanup in a separate cl.

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

Discussed with Per and decided to move to media_stream_source.h

[tommi (sloooow) - chröme, 2014/05/07 14:19:45]

Makes sense. Thanks.

+
 // Constant constraint keys which enables default audio constraints on
 // mediastreams with audio.
 struct {
   const char* key;
-  const char* value;
+  bool value;
 } const kDefaultAudioConstraints[] = {
-  { webrtc::MediaConstraintsInterface::kEchoCancellation,
-    webrtc::MediaConstraintsInterface::kValueTrue },
+  { MediaAudioConstraints::kEchoCancellation, true },
+  { MediaAudioConstraints::kGoogEchoCancellation, true },
 #if defined(OS_CHROMEOS) || defined(OS_MACOSX)
   // Enable the extended filter mode AEC on platforms with known echo issues.
-  { webrtc::MediaConstraintsInterface::kExperimentalEchoCancellation,
-    webrtc::MediaConstraintsInterface::kValueTrue },
+  { MediaAudioConstraints::kGoogExperimentalEchoCancellation, true },
+#else
+  { MediaAudioConstraints::kGoogExperimentalEchoCancellation, false },
 #endif
-  { webrtc::MediaConstraintsInterface::kAutoGainControl,
-    webrtc::MediaConstraintsInterface::kValueTrue },
-  { webrtc::MediaConstraintsInterface::kExperimentalAutoGainControl,
-    webrtc::MediaConstraintsInterface::kValueTrue },
-  { webrtc::MediaConstraintsInterface::kNoiseSuppression,
-    webrtc::MediaConstraintsInterface::kValueTrue },
-  { webrtc::MediaConstraintsInterface::kHighpassFilter,
-    webrtc::MediaConstraintsInterface::kValueTrue },
-  { webrtc::MediaConstraintsInterface::kTypingNoiseDetection,
-    webrtc::MediaConstraintsInterface::kValueTrue },
+  { MediaAudioConstraints::kGoogAutoGainControl, true },
+  { MediaAudioConstraints::kGoogExperimentalAutoGainControl, true },
+  { MediaAudioConstraints::kGoogNoiseSuppression, true },
+  { MediaAudioConstraints::kGoogHighpassFilter, true },
+  { MediaAudioConstraints::kGoogTypingNoiseDetection, true },
+  { MediaAudioConstraints::kGoogExperimentalNoiseSuppression, false },
 #if defined(OS_WIN)
-  { content::kMediaStreamAudioDucking,
-    webrtc::MediaConstraintsInterface::kValueTrue },
+  { kMediaStreamAudioDucking, true },
+#else
+  { kMediaStreamAudioDucking, false },
 #endif
 };
 
+bool GetDefaultValueForConstraint(const blink::WebMediaConstraints& constraints,
+                                  const std::string& key) {
+  // Audio constraints are false by default for gUM with a specific
+  // kMediaStreamSource, which is used by tab capture and screen capture.
+  std::string value;
+  if (GetConstraintValueAsString(constraints, kMediaStreamSource, &value))
+    return false;
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kDefaultAudioConstraints); ++i) {
+    if (kDefaultAudioConstraints[i].key == key)
+      return kDefaultAudioConstraints[i].value;
+  }
+
+  return false;
+}
+
 } // namespace
 
-void ApplyFixedAudioConstraints(RTCMediaConstraints* constraints) {
+// TODO(xians): Remove this method after the APM in WebRtc is deprecated.
+void MediaAudioConstraints::ApplyFixedAudioConstraints(
+    RTCMediaConstraints* constraints) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kDefaultAudioConstraints); ++i) {
     bool already_set_value;
     if (!webrtc::FindConstraint(constraints, kDefaultAudioConstraints[i].key,
                                 &already_set_value, NULL)) {
-      constraints->AddOptional(kDefaultAudioConstraints[i].key,
-          kDefaultAudioConstraints[i].value, false);
+      const std::string value = kDefaultAudioConstraints[i].value ?
+          webrtc::MediaConstraintsInterface::kValueTrue :
+          webrtc::MediaConstraintsInterface::kValueFalse;
+      constraints->AddOptional(kDefaultAudioConstraints[i].key, value, false);
     } else {
       DVLOG(1) << "Constraint " << kDefaultAudioConstraints[i].key
                << " already set to " << already_set_value;
     }
   }
 }
 
-bool NeedsAudioProcessing(const blink::WebMediaConstraints& constraints,
-                          int effects) {
-  RTCMediaConstraints native_constraints(constraints);
-  ApplyFixedAudioConstraints(&native_constraints);
-  if (effects & media::AudioParameters::ECHO_CANCELLER) {
-    // If platform echo canceller is enabled, disable the software AEC.
-    native_constraints.AddOptional(
-        MediaConstraintsInterface::kEchoCancellation,
-        MediaConstraintsInterface::kValueFalse, true);
-  }
+MediaAudioConstraints::MediaAudioConstraints(
+    const blink::WebMediaConstraints& constraints, int effects)
+    : constraints_(constraints), effects_(effects) {}
+
+MediaAudioConstraints::~MediaAudioConstraints() {}
+
+// TODO(xians): Remove this method after the APM in WebRtc is deprecated.
+bool MediaAudioConstraints::NeedsAudioProcessing() {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kDefaultAudioConstraints); ++i) {
-    bool value = false;
-    if (webrtc::FindConstraint(&native_constraints,
-                               kDefaultAudioConstraints[i].key, &value, NULL) &&
-        value) {
-      return true;
+    if (kDefaultAudioConstraints[i].key == kEchoCancellation) {
+      // Turn off the audio processing if |kEchoCancellation| is explicitly
+      // set the false.
+      if (!GetEchoCancellationProperty(kEchoCancellation))
+        return false;
+    } else if (kDefaultAudioConstraints[i].key == kGoogEchoCancellation) {
+      if (GetEchoCancellationProperty(kGoogEchoCancellation))
+          return true;
+    } else {
+      // |kMediaStreamAudioDucking| does not require audio processing.
+      if (kDefaultAudioConstraints[i].key != kMediaStreamAudioDucking &&
+          GetProperty(kDefaultAudioConstraints[i].key)) {
+        return true;
+      }
     }
   }
 
   return false;
 }
 
-bool GetPropertyFromConstraints(const MediaConstraintsInterface* constraints,
-                                const std::string& key) {
+bool MediaAudioConstraints::GetProperty(const std::string& key) {
+  // Return the value if the constraint is specified in |constraints|,
+  // otherwise return the default value.
   bool value = false;
-  return webrtc::FindConstraint(constraints, key, &value, NULL) && value;
+  if (!GetConstraintValueAsBoolean(constraints_, key, &value))
+    value = GetDefaultValueForConstraint(constraints_, key);
+
+  return value;
+}
+
+bool MediaAudioConstraints::GetEchoCancellationProperty(
+    const std::string& key) {
+  DCHECK(key == kEchoCancellation || key == kGoogEchoCancellation);
+
+  if (key == kEchoCancellation)
+    return GetProperty(key);
+
+  // If platform echo canceller is enabled, disable the software AEC.
+  if (effects_ & media::AudioParameters::ECHO_CANCELLER)
+    return false;
+
+  // If |kEchoCancellation| is specified in the constraints, it will
+  // overwrite the value of |kGoogEchoCancellation|.
+  bool value = false;
+  if (GetConstraintValueAsBoolean(constraints_, kEchoCancellation, &value))
+    return value;
+
+  return GetProperty(key);
+}
+
+bool MediaAudioConstraints::IsValid() {
+  blink::WebVector<blink::WebMediaConstraint> mandatory;
+  constraints_.getMandatoryConstraints(mandatory);
+  for (size_t i = 0; i < mandatory.size(); ++i) {
+    const std::string key = mandatory[i].m_name.utf8();
+    if (key == kMediaStreamSource || key == kMediaStreamSourceId ||
+        key == kSourceId) {
+      // Ignore Chrome specific Tab capture and |kSourceId| constraints.
+      continue;
+    }
+
+    bool valid = false;
+    for (size_t j = 0; j < ARRAYSIZE_UNSAFE(kDefaultAudioConstraints); ++j) {
+      if (key == kDefaultAudioConstraints[j].key) {
+        valid = true;
+        break;
+      }
+    }
+
+    if (!valid) {
+      DLOG(ERROR) << "Invalid MediaStream constraint. Name: " << key;
+      return false;
+    }
+  }
+
+  return true;
 }
 
 void EnableEchoCancellation(AudioProcessing* audio_processing) {
 #if defined(OS_ANDROID)
   // Mobile devices are using AECM.
   int err = audio_processing->echo_control_mobile()->set_routing_mode(
       webrtc::EchoControlMobile::kSpeakerphone);
   err |= audio_processing->echo_control_mobile()->Enable(true);
   CHECK_EQ(err, 0);
 #else
@@ skipping 103 matching lines @@
   }
 
   int median = 0, std = 0;
   if (!audio_processing->echo_cancellation()->GetDelayMetrics(&median, &std)) {
     stats->echo_delay_median_ms = median;
     stats->echo_delay_std_ms = std;
   }
 }
 
 }  // namespace content