Add "exact" constraint evaluation to video picker.

content/renderer/media/media_stream_video_source.cc

 // Copyright 2014 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_video_source.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 15 matching lines @@
 };
 
 // Returns true if |constraint| has mandatory constraints.
 bool HasMandatoryConstraints(const blink::WebMediaConstraints& constraints) {
   return constraints.basic().hasMandatory();
 }
 
 // Retrieve the desired max width and height from |constraints|. If not set,
 // the |desired_width| and |desired_height| are set to
 // std::numeric_limits<int>::max();
-// If either max width or height is set as a mandatory constraint, the optional
-// constraints are not checked.
+// If either max or exact width or height is set as a mandatory constraint,
+// the advanced constraints are not checked.
 void GetDesiredMaxWidthAndHeight(const blink::WebMediaConstraints& constraints,
                                  int* desired_width, int* desired_height) {
   *desired_width = std::numeric_limits<int>::max();
   *desired_height = std::numeric_limits<int>::max();
 
   const auto& basic_constraints = constraints.basic();
-  if (basic_constraints.width.hasMax() || basic_constraints.height.hasMax()) {
+
+  if (basic_constraints.width.hasMax() || basic_constraints.height.hasMax() ||
+      basic_constraints.width.hasExact() ||
+      basic_constraints.height.hasExact()) {
     if (basic_constraints.width.hasMax())
       *desired_width = basic_constraints.width.max();
     if (basic_constraints.height.hasMax())
       *desired_height = basic_constraints.height.max();
+    // Exact constraints override max constraints if both are specified.
+    // Specifying both in the same structure is meaningless.
+    if (basic_constraints.width.hasExact())
+      *desired_width = basic_constraints.width.exact();
+    if (basic_constraints.height.hasExact())
+      *desired_height = basic_constraints.height.exact();
     return;
   }
 
   for (const auto& constraint_set : constraints.advanced()) {
     if (constraint_set.width.hasMax())
       *desired_width = constraint_set.width.max();
     if (constraint_set.height.hasMax())
       *desired_height = constraint_set.height.max();
+    if (constraint_set.width.hasExact())
+      *desired_width = constraint_set.width.exact();
+    if (constraint_set.height.hasExact())
+      *desired_height = constraint_set.height.exact();
   }
 }
 
 // Retrieve the desired max and min aspect ratio from |constraints|. If not set,
 // the |min_aspect_ratio| is set to 0 and |max_aspect_ratio| is set to
 // std::numeric_limits<double>::max();
 // If either min or max aspect ratio is set as a mandatory constraint, the
 // optional constraints are not checked.
 void GetDesiredMinAndMaxAspectRatio(
     const blink::WebMediaConstraints& constraints,
@@ skipping 37 matching lines @@
   DCHECK(format != NULL);
 
   if (!format->IsValid())
     return false;
 
   // The width and height are matched based on cropping occuring later:
   // min width/height has to be >= the size of the frame (no upscale).
   // max width/height just has to be > 0 (we can crop anything too large).
   if ((constraints.width.hasMin() &&
        constraints.width.min() > format->frame_size.width()) ||
-      (constraints.width.hasMax() && constraints.width.max() <= 0)) {
+      (constraints.width.hasMax() && constraints.width.max() <= 0) ||
+      (constraints.width.hasExact() &&
+       constraints.width.exact() > format->frame_size.width())) {
     *failing_constraint_name = constraints.width.name();
   } else if ((constraints.height.hasMin() &&
               constraints.height.min() > format->frame_size.height()) ||
-             (constraints.height.hasMax() && constraints.height.max() <= 0)) {
+             (constraints.height.hasMax() && constraints.height.max() <= 0) ||
+             (constraints.height.hasExact() &&
+              constraints.height.exact() > format->frame_size.height())) {
     *failing_constraint_name = constraints.height.name();
   } else if (!constraints.frameRate.matches(format->frame_rate)) {
     if (constraints.frameRate.hasMax()) {
       const double value = constraints.frameRate.max();
       // TODO(hta): Check if handling of max = 0.0 is relevant.
       // (old handling was to set rate to 1.0 if 0.0 was specified)
       if (constraints.frameRate.matches(value)) {
         format->frame_rate =
             (format->frame_rate > value) ? value : format->frame_rate;
         return true;
@@ skipping 13 matching lines @@
 void FilterFormatsByConstraints(
     const blink::WebMediaTrackConstraintSet& constraints,
     media::VideoCaptureFormats* formats,
     std::string* failing_constraint_name) {
   media::VideoCaptureFormats::iterator format_it = formats->begin();
   while (format_it != formats->end()) {
     // Modify |format_it| to fulfill the constraint if possible.
     // Delete it otherwise.
     if (!UpdateFormatForConstraints(constraints, &(*format_it),
                                     failing_constraint_name)) {
+      DVLOG(2) << "Format filter: Discarding format "
+               << format_it->frame_size.width() << "x"
+               << format_it->frame_size.height() << "@"
+               << format_it->frame_rate;
       format_it = formats->erase(format_it);
     } else {
       ++format_it;
     }
   }
 }
 
 // Returns the media::VideoCaptureFormats that matches |constraints|.
 // If the return value is empty, and the reason is a specific constraint,
 // |unsatisfied_constraint| returns the name of the constraint.
@@ skipping 407 matching lines @@
       callback(callback) {
 }
 
 MediaStreamVideoSource::TrackDescriptor::TrackDescriptor(
     const TrackDescriptor& other) = default;
 
 MediaStreamVideoSource::TrackDescriptor::~TrackDescriptor() {
 }
 
 }  // namespace content