Support the googNoiseReduction constraint in SelectSettings for video-device capture.

content/renderer/media/media_stream_constraints_util_video_device.cc

 // Copyright 2017 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_constraints_util_video_device.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
 #include <vector>
 
 #include "content/renderer/media/media_stream_constraints_util.h"
 #include "content/renderer/media/media_stream_video_source.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 namespace content {
 
 namespace {
 
 // Number of default settings to be used as final tie-breaking criteria for
 // settings that are equally good at satisfying constraints:
-// device ID, power-line frequency, resolution and frame rate.
-const int kNumDefaultDistanceEntries = 4;
+// device ID, power-line frequency, noise reduction, resolution and frame rate.
+const int kNumDefaultDistanceEntries = 5;
 
 // The default resolution to be preferred as tie-breaking criterion.
 const int kDefaultResolutionArea = MediaStreamVideoSource::kDefaultWidth *
                                    MediaStreamVideoSource::kDefaultHeight;
 
 // The minimum aspect ratio to be supported by sources.
 const double kMinSourceAspectRatio = 0.05;
 
 // VideoKind enum values. See https://w3c.github.io/mediacapture-depth.
 const char kVideoKindColor[] = "color";
@@ skipping 17 matching lines @@
 struct VideoDeviceCaptureSourceSettings {
  public:
   VideoDeviceCaptureSourceSettings()
       : facing_mode_(::mojom::FacingMode::NONE),
         power_line_frequency_(media::PowerLineFrequency::FREQUENCY_DEFAULT) {}
 
   VideoDeviceCaptureSourceSettings(
       const std::string& device_id,
       const media::VideoCaptureFormat& format,
       ::mojom::FacingMode facing_mode,
-      media::PowerLineFrequency power_line_frequency)
+      media::PowerLineFrequency power_line_frequency,
+      const rtc::Optional<bool>& noise_reduction)
       : device_id_(device_id),
         format_(format),
         facing_mode_(facing_mode),
-        power_line_frequency_(power_line_frequency) {}
+        power_line_frequency_(power_line_frequency),
+        noise_reduction_(noise_reduction) {}
 
   VideoDeviceCaptureSourceSettings(
       const VideoDeviceCaptureSourceSettings& other) = default;
   VideoDeviceCaptureSourceSettings& operator=(
       const VideoDeviceCaptureSourceSettings& other) = default;
   VideoDeviceCaptureSourceSettings(VideoDeviceCaptureSourceSettings&& other) =
       default;
   VideoDeviceCaptureSourceSettings& operator=(
       VideoDeviceCaptureSourceSettings&& other) = default;
   ~VideoDeviceCaptureSourceSettings() = default;
@@ skipping 14 matching lines @@
     return GetVideoKindForFormat(format_);
   }
 
   // Accessors.
   const media::VideoCaptureFormat& format() const { return format_; }
   const std::string& device_id() const { return device_id_; }
   ::mojom::FacingMode facing_mode() const { return facing_mode_; }
   media::PowerLineFrequency power_line_frequency() const {
     return power_line_frequency_;
   }
+  const rtc::Optional<bool>& noise_reduction() const {
+    return noise_reduction_;
+  }
 
  private:
   std::string device_id_;
   media::VideoCaptureFormat format_;
   ::mojom::FacingMode facing_mode_;
   media::PowerLineFrequency power_line_frequency_;
+  rtc::Optional<bool> noise_reduction_;
 };
 
 VideoDeviceCaptureSourceSelectionResult ResultFromSettings(
     const VideoDeviceCaptureSourceSettings& settings) {
   VideoDeviceCaptureSourceSelectionResult result;
   result.capture_params.power_line_frequency = settings.power_line_frequency();
   result.capture_params.requested_format = settings.format();
   result.device_id = settings.device_id();
   result.facing_mode = settings.facing_mode();
+  result.noise_reduction = settings.noise_reduction();
   result.failed_constraint_name = nullptr;
 
   return result;
 }
 
 // Generic distance function between two numeric values. Based on the fitness
 // distance function described in
 // https://w3c.github.io/mediacapture-main/#dfn-fitness-distance
 double Distance(double value1, double value2) {
   if (std::fabs(value1 - value2) <= blink::DoubleConstraint::kConstraintEpsilon)
@@ skipping 190 matching lines @@
   if ((constraint_has_max && source_value_long > constraint_max) ||
       (constraint_has_min && source_value_long < constraint_min)) {
     if (failed_constraint_name)
       *failed_constraint_name = constraint.name();
     return HUGE_VAL;
   }
 
   return 0.0;
 }
 
+// Returns a custom distance function suitable for the googNoiseReduction
+// constraint, given  a |constraint| and a candidate value |value|.
+// The distance is HUGE_VAL if |candidate_value| cannot satisfy |constraint|.
+// Otherwise, the distance is zero.
+double NoiseReductionConstraintSourceDistance(
+    const blink::BooleanConstraint& constraint,
+    const rtc::Optional<bool>& value,
+    const char** failed_constraint_name) {
+  if (!constraint.hasExact())
+    return 0.0;
+
+  if (value && *value == constraint.exact())
+    return 0.0;
+
+  if (failed_constraint_name)
+    *failed_constraint_name = constraint.name();
+  return HUGE_VAL;
+}
+
 // Returns a custom distance for constraints that depend on the device
 // characteristics that have a fixed value.
 double DeviceSourceDistance(
     const std::string& device_id,
     ::mojom::FacingMode facing_mode,
     const blink::WebMediaTrackConstraintSet& constraint_set,
     const char** failed_constraint_name) {
   return StringConstraintSourceDistance(blink::WebString::fromASCII(device_id),
                                         constraint_set.deviceId,
                                         failed_constraint_name) +
@@ skipping 35 matching lines @@
 double CandidateSourceDistance(
     const VideoDeviceCaptureSourceSettings& candidate,
     const blink::WebMediaTrackConstraintSet& constraint_set,
     const char** failed_constraint_name) {
   return DeviceSourceDistance(candidate.device_id(), candidate.facing_mode(),
                               constraint_set, failed_constraint_name) +
          FormatSourceDistance(candidate.format(), constraint_set,
                               failed_constraint_name) +
          PowerLineFrequencyConstraintSourceDistance(
              constraint_set.googPowerLineFrequency,
-             candidate.power_line_frequency(), failed_constraint_name);
+             candidate.power_line_frequency(), failed_constraint_name) +
+         NoiseReductionConstraintSourceDistance(
+             constraint_set.googNoiseReduction, candidate.noise_reduction(),
+             failed_constraint_name);
 }
 
 // Returns the fitness distance between |value| and |constraint|.
 // Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance.
 double StringConstraintFitnessDistance(
     const blink::WebString& value,
     const blink::StringConstraint& constraint) {
   if (!constraint.hasIdeal())
     return 0.0;
 
@@ skipping 111 matching lines @@
     return 0.0;
 
   // This constraint is of type long, but it behaves as an enum. Thus, values
   // equal to ideal have fitness 0.0 and any other values have fitness 1.0.
   if (value == constraint.ideal())
     return 0.0;
 
   return 1.0;
 }
 
+// Returns the fitness distance between |value| and |constraint| for the
+// googNoiseReduction constraint.
+// Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance.
+double NoiseReductionConstraintFitnessDistance(
+    const rtc::Optional<bool>& value,
+    const blink::BooleanConstraint& constraint) {
+  if (!constraint.hasIdeal())
+    return 0.0;
+
+  if (value && value == constraint.ideal())
+    return 0.0;
+
+  return 1.0;
+}
+
 // Returns the fitness distance between a settings candidate and a constraint
 // set. The returned value is the sum of the fitness distances between each
 // setting in |candidate| and the corresponding constraint in |constraint_set|.
 // Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance.
 double CandidateFitnessDistance(
     const VideoDeviceCaptureSourceSettings& candidate,
     const blink::WebMediaTrackConstraintSet& constraint_set) {
   DCHECK(std::isfinite(
       CandidateSourceDistance(candidate, constraint_set, nullptr)));
   double fitness = 0.0;
   fitness += AspectRatioConstraintFitnessDistance(
       candidate.GetHeight(), candidate.GetWidth(), constraint_set.height,
       constraint_set.width, constraint_set.aspectRatio);
   fitness += StringConstraintFitnessDistance(candidate.GetDeviceId(),
                                              constraint_set.deviceId);
   fitness += StringConstraintFitnessDistance(candidate.GetFacingMode(),
                                              constraint_set.facingMode);
   fitness += FrameRateConstraintFitnessDistance(candidate.GetFrameRate(),
                                                 constraint_set.frameRate);
   fitness += StringConstraintFitnessDistance(candidate.GetVideoKind(),
                                              constraint_set.videoKind);
   fitness += PowerLineFrequencyConstraintFitnessDistance(
       candidate.GetPowerLineFrequency(), constraint_set.googPowerLineFrequency);
+  fitness += NoiseReductionConstraintFitnessDistance(
+      candidate.noise_reduction(), constraint_set.googNoiseReduction);
   fitness += ResolutionConstraintFitnessDistance(candidate.GetHeight(),
                                                  constraint_set.height);
   fitness += ResolutionConstraintFitnessDistance(candidate.GetWidth(),
                                                  constraint_set.width);
 
   return fitness;
 }
 
 // Returns the native fitness distance between a settings candidate and a
 // constraint set. The returned value is the sum of the fitness distances for
@@ skipping 37 matching lines @@
   }
 
   // Prefer default power-line frequency.
   double power_line_frequency_distance =
       candidate.power_line_frequency() ==
               media::PowerLineFrequency::FREQUENCY_DEFAULT
           ? 0.0
           : HUGE_VAL;
   distance_vector->push_back(power_line_frequency_distance);
 
+  // Prefer not having a specific noise-reduction value and let the lower-layers
+  // implementation choose a noise-reduction strategy.
+  double noise_reduction_distance =
+      candidate.noise_reduction() ? HUGE_VAL : 0.0;
+  distance_vector->push_back(noise_reduction_distance);
+
   // Prefer a resolution with area close to the default.
   int candidate_area = candidate.format().frame_size.GetArea();
   double resolution_distance =
       candidate_area == kDefaultResolutionArea
           ? 0.0
           : Distance(candidate_area, kDefaultResolutionArea);
   distance_vector->push_back(resolution_distance);
 
   // Prefer a frame rate close to the default.
   double frame_rate_distance =
@@ skipping 81 matching lines @@
         continue;
 
       for (auto& power_line_frequency : capabilities.power_line_capabilities) {
         double basic_power_line_frequency_distance =
             PowerLineFrequencyConstraintSourceDistance(
                 constraints.basic().googPowerLineFrequency,
                 power_line_frequency, &failed_constraint_name);
         if (!std::isfinite(basic_power_line_frequency_distance))
           continue;
 
-        // The candidate satisfies the basic constraint set.
-        double candidate_basic_custom_distance =
-            basic_device_distance + basic_format_distance +
-            basic_power_line_frequency_distance;
-        DCHECK(std::isfinite(candidate_basic_custom_distance));
+        for (auto& noise_reduction :
+             capabilities.noise_reduction_capabilities) {
+          double basic_noise_reduction_distance =
+              NoiseReductionConstraintSourceDistance(
+                  constraints.basic().googNoiseReduction, noise_reduction,
+                  &failed_constraint_name);
+          if (!std::isfinite(basic_noise_reduction_distance))
+            continue;
 
-        // Temporary vector to save custom distances for advanced constraints.
-        // Custom distances must be added to the candidate distance vector after
-        // all the spec-mandated values.
-        DistanceVector advanced_custom_distance_vector;
-        VideoDeviceCaptureSourceSettings candidate(device->device_id, format,
-                                                   device->facing_mode,
-                                                   power_line_frequency);
-        DistanceVector candidate_distance_vector;
-        // First criteria for valid candidates is satisfaction of advanced
-        // constraint sets.
-        for (const auto& advanced : constraints.advanced()) {
-          double custom_distance =
-              CandidateSourceDistance(candidate, advanced, nullptr);
-          advanced_custom_distance_vector.push_back(custom_distance);
-          double spec_distance = std::isfinite(custom_distance) ? 0 : 1;
-          candidate_distance_vector.push_back(spec_distance);
-        }
+          // The candidate satisfies the basic constraint set.
+          double candidate_basic_custom_distance =
+              basic_device_distance + basic_format_distance +
+              basic_power_line_frequency_distance +
+              basic_noise_reduction_distance;
+          DCHECK(std::isfinite(candidate_basic_custom_distance));
 
-        // Second criterion is fitness distance.
-        candidate_distance_vector.push_back(
-            CandidateFitnessDistance(candidate, constraints.basic()));
+          // Temporary vector to save custom distances for advanced constraints.
+          // Custom distances must be added to the candidate distance vector
+          // after all the spec-mandated values.
+          DistanceVector advanced_custom_distance_vector;
+          VideoDeviceCaptureSourceSettings candidate(
+              device->device_id, format, device->facing_mode,
+              power_line_frequency, noise_reduction);
+          DistanceVector candidate_distance_vector;
+          // First criteria for valid candidates is satisfaction of advanced
+          // constraint sets.
+          for (const auto& advanced : constraints.advanced()) {
+            double custom_distance =
+                CandidateSourceDistance(candidate, advanced, nullptr);
+            advanced_custom_distance_vector.push_back(custom_distance);
+            double spec_distance = std::isfinite(custom_distance) ? 0 : 1;
+            candidate_distance_vector.push_back(spec_distance);
+          }
 
-        // Third criteria are custom distances to constraint sets.
-        candidate_distance_vector.push_back(candidate_basic_custom_distance);
-        std::copy(advanced_custom_distance_vector.begin(),
-                  advanced_custom_distance_vector.end(),
-                  std::back_inserter(candidate_distance_vector));
+          // Second criterion is fitness distance.
+          candidate_distance_vector.push_back(
+              CandidateFitnessDistance(candidate, constraints.basic()));
 
-        // Fourth criteria is native fitness distance.
-        candidate_distance_vector.push_back(
-            CandidateNativeFitnessDistance(candidate, constraints.basic()));
+          // Third criteria are custom distances to constraint sets.
+          candidate_distance_vector.push_back(candidate_basic_custom_distance);
+          std::copy(advanced_custom_distance_vector.begin(),
+                    advanced_custom_distance_vector.end(),
+                    std::back_inserter(candidate_distance_vector));
 
-        // Final criteria are custom distances to default settings.
-        AppendDistanceFromDefault(candidate, capabilities,
-                                  &candidate_distance_vector);
+          // Fourth criteria is native fitness distance.
+          candidate_distance_vector.push_back(
+              CandidateNativeFitnessDistance(candidate, constraints.basic()));
 
-        DCHECK_EQ(best_distance.size(), candidate_distance_vector.size());
-        if (candidate_distance_vector < best_distance) {
-          best_distance = candidate_distance_vector;
-          result = ResultFromSettings(candidate);
+          // Final criteria are custom distances to default settings.
+          AppendDistanceFromDefault(candidate, capabilities,
+                                    &candidate_distance_vector);
+
+          DCHECK_EQ(best_distance.size(), candidate_distance_vector.size());
+          if (candidate_distance_vector < best_distance) {
+            best_distance = candidate_distance_vector;
+            result = ResultFromSettings(candidate);
+          }
         }
       }
     }
   }
 
   if (!result.HasValue())
     result.failed_constraint_name = failed_constraint_name;
 
   return result;
 }
 
 }  // namespace content