Reland "SelectSettings algorithm for audio constraints."

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>
@@ skipping 171 matching lines @@
       basic_constraint_set, constrained_format.constrained_resolution(),
       constrained_format.constrained_frame_rate(),
       capture_params.requested_format, expect_source_native_size);
 
   return VideoCaptureSettings(
       candidate.device_id(), capture_params, candidate.noise_reduction(),
       track_adapter_settings, constrained_format.constrained_frame_rate().Min(),
       constrained_format.constrained_frame_rate().Max());
 }
 
-// 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)
-    return 0.0;
-
-  return std::fabs(value1 - value2) /
-         std::max(std::fabs(value1), std::fabs(value2));
-}
-
 // Returns a pair with the minimum and maximum aspect ratios supported by the
 // candidate format |constrained_format|, subject to given width and height
 // constraints.
 void GetSourceAspectRatioRange(const ConstrainedFormat& constrained_format,
                                const blink::LongConstraint& height_constraint,
                                const blink::LongConstraint& width_constraint,
                                double* min_source_aspect_ratio,
                                double* max_source_aspect_ratio) {
   long min_height = constrained_format.MinHeight();
   if (ConstraintHasMin(height_constraint))
@@ skipping 64 matching lines @@
       (constraint_has_min && max_source_value < constraint_min) ||
       (constraint_has_min && constraint_has_max &&
        constraint_min > constraint_max)) {
     if (failed_constraint_name)
       *failed_constraint_name = constraint.GetName();
     return HUGE_VAL;
   }
 
   // If the source value exceeds the maximum requested, penalize.
   if (constraint_has_max && native_source_value > constraint_max)
-    return Distance(native_source_value, constraint_max);
+    return NumericConstraintFitnessDistance(native_source_value,
+                                            constraint_max);
 
   return 0.0;
 }
 
 // Returns a custom distance function suitable for frame rate, given
 // a |constraint| and a candidate format |constrained_format|.
 // A source can support track frame rates in the interval
 // [min_frame_rate, max_frame_rate], using frame-rate adjustments if
 // necessary. If the candidate range and the constraint range are disjoint,
 // return HUGE_VAL.
@@ skipping 21 matching lines @@
       (constraint_has_min && constraint_has_max &&
        constraint_min > constraint_max)) {
     if (failed_constraint_name)
       *failed_constraint_name = constraint.GetName();
     return HUGE_VAL;
   }
 
   // Compute the cost using the native rate.
   if (constraint_has_max &&
       constrained_format.native_frame_rate() > constraint_max)
-    return Distance(constrained_format.native_frame_rate(), constraint_max);
+    return NumericConstraintFitnessDistance(
+        constrained_format.native_frame_rate(), constraint_max);
 
   return 0.0;
 }
 
 // Returns a custom distance function suitable for aspect ratio, given
 // the values for the aspect_ratio, width and height constraints, and a
 // candidate format |constrained_format|.
 // A source can support track resolutions that range from
 //    min_width x min_height  to  max_width x max_height
 // where
@@ skipping 153 matching lines @@
          FormatSourceDistance(candidate.format(), constrained_format,
                               constraint_set, failed_constraint_name) +
          PowerLineFrequencyConstraintSourceDistance(
              constraint_set.goog_power_line_frequency,
              candidate.power_line_frequency(), failed_constraint_name) +
          NoiseReductionConstraintSourceDistance(
              constraint_set.goog_noise_reduction, 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;
-
-  for (auto& ideal_value : constraint.Ideal()) {
-    if (value == ideal_value)
-      return 0.0;
-  }
-
-  return 1.0;
-}
-
 // Returns the fitness distance between |value| and |constraint| for
 // resolution constraints (i.e., width and height).
 // Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance.
 double ResolutionConstraintFitnessDistance(
     long value,
     const blink::LongConstraint& constraint) {
   if (!constraint.HasIdeal())
     return 0.0;
 
   // Source resolutions greater than ideal support the ideal value with
   // cropping.
   if (value >= constraint.Ideal())
     return 0.0;
 
-  return Distance(value, constraint.Ideal());
+  return NumericConstraintFitnessDistance(value, constraint.Ideal());
 }
 
 // Returns the fitness distance between |value| and |constraint| for
 // resolution constraints (i.e., width and height), ignoring cropping.
 // This measures how well a native resolution supports the idea value.
 // Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance.
 double ResolutionConstraintNativeFitnessDistance(
     long value,
     const blink::LongConstraint& constraint) {
-  return constraint.HasIdeal() ? Distance(value, constraint.Ideal()) : 0.0;
+  return constraint.HasIdeal()
+             ? NumericConstraintFitnessDistance(value, constraint.Ideal())
+             : 0.0;
 }
 
 // Returns the fitness distance between a source resolution settings
 // and the aspectRatio constraint, taking into account resolution restrictions
 // on the source imposed by the width and height constraints.
 // Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance.
 double AspectRatioConstraintFitnessDistance(
     const ConstrainedFormat& constrained_format,
     const blink::LongConstraint& height_constraint,
     const blink::LongConstraint& width_constraint,
     const blink::DoubleConstraint& aspect_ratio_constraint) {
   if (!aspect_ratio_constraint.HasIdeal())
     return 0.0;
 
   double min_source_aspect_ratio;
   double max_source_aspect_ratio;
   GetSourceAspectRatioRange(constrained_format, height_constraint,
                             width_constraint, &min_source_aspect_ratio,
                             &max_source_aspect_ratio);
 
   // If the supported aspect ratio range does not include the ideal aspect
   // ratio, compute fitness using the spec formula.
   if (max_source_aspect_ratio <
       aspect_ratio_constraint.Ideal() -
           blink::DoubleConstraint::kConstraintEpsilon) {
-    return Distance(max_source_aspect_ratio, aspect_ratio_constraint.Ideal());
+    return NumericConstraintFitnessDistance(max_source_aspect_ratio,
+                                            aspect_ratio_constraint.Ideal());
   }
 
   if (min_source_aspect_ratio >
       aspect_ratio_constraint.Ideal() +
           blink::DoubleConstraint::kConstraintEpsilon) {
-    return Distance(min_source_aspect_ratio, aspect_ratio_constraint.Ideal());
+    return NumericConstraintFitnessDistance(min_source_aspect_ratio,
+                                            aspect_ratio_constraint.Ideal());
   }
 
   // Otherwise, the ideal aspect ratio can be supported and the fitness is 0.
   return 0.0;
 }
 
 // Returns the fitness distance between |value| and |constraint| for the
 // frameRate constraint.
 // Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance.
 double FrameRateConstraintFitnessDistance(
     double value,
     const blink::DoubleConstraint& constraint) {
   if (!constraint.HasIdeal())
     return 0.0;
 
   // Source frame rates greater than ideal support the ideal value using
   // frame-rate adjustment.
   if (value >=
       constraint.Ideal() - blink::DoubleConstraint::kConstraintEpsilon) {
     return 0.0;
   }
 
-  return Distance(value, constraint.Ideal());
+  return NumericConstraintFitnessDistance(value, constraint.Ideal());
 }
 
 // Returns the fitness distance between |value| and |constraint| for the
 // frameRate constraint, ignoring frame-rate adjustment.
 // It measures how well the native frame rate supports the ideal value.
 // Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance.
 double FrameRateConstraintNativeFitnessDistance(
     double value,
     const blink::DoubleConstraint& constraint) {
-  return constraint.HasIdeal() ? Distance(value, constraint.Ideal()) : 0.0;
+  return constraint.HasIdeal()
+             ? NumericConstraintFitnessDistance(value, constraint.Ideal())
+             : 0.0;
 }
 
 // Returns the fitness distance between |value| and |constraint| for the
 // googPowerLineFrequency constraint.
 // Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance.
 double PowerLineFrequencyConstraintFitnessDistance(
     long value,
     const blink::LongConstraint& constraint) {
   if (!constraint.HasIdeal())
     return 0.0;
@@ skipping 109 matching lines @@
   // 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);
+          : NumericConstraintFitnessDistance(candidate_area,
+                                             kDefaultResolutionArea);
   distance_vector->push_back(resolution_distance);
 
   // Prefer a frame rate close to the default.
   double frame_rate_distance =
       candidate.format().frame_rate == MediaStreamVideoSource::kDefaultFrameRate
           ? 0.0
-          : Distance(candidate.format().frame_rate,
-                     MediaStreamVideoSource::kDefaultFrameRate);
+          : NumericConstraintFitnessDistance(
+                candidate.format().frame_rate,
+                MediaStreamVideoSource::kDefaultFrameRate);
   distance_vector->push_back(frame_rate_distance);
 }
 
 }  // namespace
 
 blink::WebString GetVideoKindForFormat(
     const media::VideoCaptureFormat& format) {
   return (format.pixel_format == media::PIXEL_FORMAT_Y16)
              ? blink::WebString::FromASCII(kVideoKindDepth)
              : blink::WebString::FromASCII(kVideoKindColor);
@@ skipping 121 matching lines @@
     }
   }
 
   if (!result.HasValue())
     return VideoCaptureSettings(failed_constraint_name);
 
   return result;
 }
 
 }  // namespace content