Introduce SelectSettings algorithm for MediaStream video tracks.

content/renderer/media/media_stream_constraints_util_sets.h

 // 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_MEDIA_STREAM_CONSTRAINTS_UTIL_SETS_H_
 #define CONTENT_RENDERER_MEDIA_MEDIA_STREAM_CONSTRAINTS_UTIL_SETS_H_
 
 #include <algorithm>
 #include <limits>
 #include <utility>
@@ skipping 125 matching lines @@
   bool is_universal_;
   std::vector<T> elements_;
 };
 
 // This class represents a set of (height, width) screen resolution candidates
 // determined by width, height and aspect-ratio constraints.
 // This class supports widths and heights from 0 to kMaxDimension, both
 // inclusive and aspect ratios from 0.0 to positive infinity, both inclusive.
 class CONTENT_EXPORT ResolutionSet {
  public:
-  static constexpr int kMaxDimension = std::numeric_limits<int>::max();
+  static const int kMaxDimension = std::numeric_limits<int>::max();
 
   // Helper class that represents (height, width) points on a plane.
   // TODO(guidou): Use a generic point/vector class that uses double once it
   // becomes available (e.g., a gfx::Vector2dD).
   class CONTENT_EXPORT Point {
    public:
     // Creates a (|height|, |width|) point. |height| and |width| must be finite.
     Point(double height, double width);
     Point(const Point& other);
     Point& operator=(const Point& other);
@@ skipping 82 matching lines @@
   // * If two ideal values are given, they are used to determine a single ideal
   //   point, which can be one of:
   //    - (|ideal_height|, |ideal_width|),
   //    - (|ideal_height|, |ideal_height|*|ideal_aspect_ratio|), or
   //    - (|ideal_width| / |ideal_aspect_ratio|, |ideal_width|).
   //   The point in the set closest to the ideal point is returned.
   // * If a single ideal value is given, a point in the set closest to the line
   //   defined by the ideal value is returned. If there is more than one point
   //   closest to the ideal line, the following tie-breaker rules are used:
   //  - If |ideal_height| is provided, the point closest to
-  //      (|ideal_height|, |ideal_height| * kDefaultAspectRatio).
+  //      (|ideal_height|, |ideal_height| * default_aspect_ratio), where
+  //      default_aspect_ratio is the result of the floating-point division
+  //      |default_width|/|default_height|.
   //  - If |ideal_width| is provided, the point closest to
-  //      (|ideal_width| / kDefaultAspectRatio, |ideal_width|).
+  //      (|ideal_width| / default_aspect_ratio, |ideal_width|).
   //  - If |ideal_aspect_ratio| is provided, the point with largest area among
   //    the points closest to
-  //      (kDefaultHeight, kDefaultHeight * aspect_ratio) and
-  //      (kDefaultWidth / aspect_ratio, kDefaultWidth),
+  //      (|default_height|, |default_height| * aspect_ratio) and
+  //      (|default_width| / aspect_ratio, |default_width|),
   //    where aspect_ratio is |ideal_aspect_ratio| if the ideal line intersects
   //    the set, and the closest aspect ratio to |ideal_aspect_ratio| among the
   //    points in the set if no point in the set has an aspect ratio equal to
   //    |ideal_aspect_ratio|.
   // * If no ideal value is given, proceed as if only |ideal_aspect_ratio| was
-  //   provided with a value of kDefaultAspectRatio.
+  //   provided with a value of default_aspect_ratio.
   //
   // This is intended to support the implementation of the spec algorithm for
   // selection of track settings, as defined in
   // https://w3c.github.io/mediacapture-main/#dfn-selectsettings.
   //
   // The main difference between this algorithm and the spec is that when ideal
   // values are provided, the spec mandates finding a point that minimizes the
   // sum of custom relative distances for each provided ideal value, while this
   // algorithm minimizes either the Euclidean distance (sum of square distances)
   // on a height-width plane for the cases where two or three ideal values are
   // provided, or the absolute distance for the case with one ideal value.
   // Also, in the case with three ideal values, this algorithm ignores the
   // distance to the ideal aspect ratio.
   // In most cases the difference in the final result should be negligible.
   // The reason to follow this approach is that optimization in the worst case
   // is reduced to projection of a point on line segment, which is a simple
   // operation that provides exact results. Using the distance function of the
   // spec, which is not continuous, would require complex optimization methods
   // that do not necessarily guarantee finding the real optimal value.
   //
   // This function has undefined behavior if this set is empty.
   Point SelectClosestPointToIdeal(
-      const blink::WebMediaTrackConstraintSet& constraint_set) const;
+      const blink::WebMediaTrackConstraintSet& constraint_set,
+      int default_height,
+      int default_width) const;
 
   // Utilities that return ResolutionSets constrained on a specific variable.
   static ResolutionSet FromHeight(int min, int max);
   static ResolutionSet FromExactHeight(int value);
   static ResolutionSet FromWidth(int min, int max);
   static ResolutionSet FromExactWidth(int value);
   static ResolutionSet FromAspectRatio(double min, double max);
   static ResolutionSet FromExactAspectRatio(double value);
 
   // Returns a ResolutionCandidateSet initialized with |constraint_set|'s
   // width, height and aspectRatio constraints.
   static ResolutionSet FromConstraintSet(
       const blink::WebMediaTrackConstraintSet& constraint_set);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(MediaStreamConstraintsUtilSetsTest,
                            ResolutionVertices);
   FRIEND_TEST_ALL_PREFIXES(MediaStreamConstraintsUtilSetsTest,
                            ResolutionPointSetClosestPoint);
   FRIEND_TEST_ALL_PREFIXES(MediaStreamConstraintsUtilSetsTest,
                            ResolutionLineSetClosestPoint);
   FRIEND_TEST_ALL_PREFIXES(MediaStreamConstraintsUtilSetsTest,
                            ResolutionGeneralSetClosestPoint);
   FRIEND_TEST_ALL_PREFIXES(MediaStreamConstraintsUtilSetsTest,
                            ResolutionIdealOutsideSinglePoint);
 
   // Implements SelectClosestPointToIdeal() for the case when only the ideal
   // aspect ratio is provided.
-  Point SelectClosestPointToIdealAspectRatio(double ideal_aspect_ratio) const;
+  Point SelectClosestPointToIdealAspectRatio(double ideal_aspect_ratio,
+                                             int default_height,
+                                             int default_width) const;
 
   // Returns the closest point in this set to |point|. If |point| is included in
   // this set, Point is returned. If this set is empty, behavior is undefined.
   Point ClosestPointTo(const Point& point) const;
 
   // Returns the vertices of the set that have the property accessed
   // by |accessor| closest to |value|. The returned vector always has one or two
   // elements. Behavior is undefined if the set is empty.
   std::vector<Point> GetClosestVertices(double (Point::*accessor)() const,
                                         double value) const;
@@ skipping 23 matching lines @@
   double max_aspect_ratio_;
 };
 
 // Scalar multiplication for Points.
 ResolutionSet::Point CONTENT_EXPORT operator*(double d,
                                               const ResolutionSet::Point& p);
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_MEDIA_STREAM_CONSTRAINTS_UTIL_SETS_H_