Introduce SelectSettings algorithm for MediaStream video tracks.

content/renderer/media/media_stream_constraints_util.cc

Index: content/renderer/media/media_stream_constraints_util.cc
diff --git a/content/renderer/media/media_stream_constraints_util.cc b/content/renderer/media/media_stream_constraints_util.cc
index 8c886bd68bd45f077d0f1c84428837c097282fe5..f00800199b73b1ab2a2b26b8cbb03d88432a6f76 100644
--- a/content/renderer/media/media_stream_constraints_util.cc
+++ b/content/renderer/media/media_stream_constraints_util.cc
@@ -4,8 +4,12 @@
 
 #include "content/renderer/media/media_stream_constraints_util.h"
 
+#include <algorithm>
+#include <utility>
+
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "content/renderer/media/media_stream_constraints_util_sets.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
@@ -91,6 +95,36 @@ bool ScanConstraintsForMinValue(const blink::WebMediaConstraints& constraints,
 
 }  // namespace
 
+VideoCaptureSettings::VideoCaptureSettings() : VideoCaptureSettings("") {}
+
+VideoCaptureSettings::VideoCaptureSettings(const char* failed_constraint_name)
+    : failed_constraint_name_(failed_constraint_name) {}
+
+VideoCaptureSettings::VideoCaptureSettings(
+    std::string device_id,
+    ::mojom::FacingMode facing_mode,
+    media::VideoCaptureParams capture_params,
+    base::Optional<bool> noise_reduction,
+    const VideoTrackAdapterSettings& track_adapter_settings,
+    double min_frame_rate)
+    : failed_constraint_name_(nullptr),
+      device_id_(std::move(device_id)),
+      facing_mode_(facing_mode),
+      capture_params_(capture_params),
+      noise_reduction_(noise_reduction),
+      track_adapter_settings_(track_adapter_settings),
+      min_frame_rate_(min_frame_rate) {}

[hbos_chromium, 2017/03/28 12:52:53]

Should we DCHECK that the video capture params are within the track adapter
settings min/max ranges?
No, right, cropping means we can have a lower track max than capture params...
Do we support up-scaling as well or should we DCHECK that track min <= capture
params max?

[Guido Urdaneta, 2017/03/28 18:35:43]

We don't support upscaling. The source must provide frames that satisfy the
constraint limits. The adapter could in principle upscale them, but it currently
doesn't do that.
Added a few DCHECKs that are relevant, though.

+
+VideoCaptureSettings::VideoCaptureSettings(const VideoCaptureSettings& other) =
+    default;
+VideoCaptureSettings::VideoCaptureSettings(VideoCaptureSettings&& other) =
+    default;
+VideoCaptureSettings::~VideoCaptureSettings() = default;
+VideoCaptureSettings& VideoCaptureSettings::operator=(
+    const VideoCaptureSettings& other) = default;
+VideoCaptureSettings& VideoCaptureSettings::operator=(
+    VideoCaptureSettings&& other) = default;
+
 bool GetConstraintValueAsBoolean(
     const blink::WebMediaConstraints& constraints,
     const blink::BooleanConstraint blink::WebMediaTrackConstraintSet::*picker,
@@ -162,4 +196,38 @@ rtc::Optional<bool> ConstraintToOptional(
   return rtc::Optional<bool>();
 }
 
+VideoTrackAdapterSettings SelectVideoTrackAdapterSettings(
+    const blink::WebMediaTrackConstraintSet& basic_constraint_set,
+    const ResolutionSet& resolution_set,
+    const NumericRangeSet<double>& frame_rate_set,
+    const media::VideoCaptureFormat& source_format) {
+  ResolutionSet::Point resolution = resolution_set.SelectClosestPointToIdeal(
+      basic_constraint_set, source_format.frame_size.height(),
+      source_format.frame_size.width());
+  int track_max_height = static_cast<int>(std::round(resolution.height()));
+  int track_max_width = static_cast<int>(std::round(resolution.width()));
+  double track_min_aspect_ratio =
+      std::max(resolution_set.min_aspect_ratio(),
+               static_cast<double>(resolution_set.min_width()) /
+                   static_cast<double>(resolution_set.max_height()));
+  double track_max_aspect_ratio =
+      std::min(resolution_set.max_aspect_ratio(),
+               static_cast<double>(resolution_set.max_width()) /
+                   static_cast<double>(resolution_set.min_height()));
+  double track_max_frame_rate = frame_rate_set.Max();
+  if (basic_constraint_set.frameRate.hasIdeal()) {
+    track_max_frame_rate = std::min(
+        track_max_frame_rate,
+        std::max(basic_constraint_set.frameRate.ideal(), frame_rate_set.Min()));
+  }
+  // VideoTrackAdapter uses a frame rate of 0.0 to disable frame-rate
+  // adjustment.
+  if (track_max_frame_rate >= source_format.frame_rate)
+    track_max_frame_rate = 0.0;
+
+  return VideoTrackAdapterSettings(
+      track_max_width, track_max_height, track_min_aspect_ratio,
+      track_max_aspect_ratio, track_max_frame_rate);
+}
+
 }  // namespace content