Media Capture Depth Stream Extensions API: videoKind settings and constraint.

content/renderer/media/media_stream_constraints_util_video_source.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_source.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
 #include <vector>
 
 #include "content/renderer/media/media_stream_video_source.h"
+#include "content/renderer/media/media_stream_video_track.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.
@@ skipping 276 matching lines @@
                                             failed_constraint_name) +
          ResolutionConstraintSourceDistance(format.frame_size.width(),
                                             constraint_set.width,
                                             failed_constraint_name) +
          AspectRatioConstraintSourceDistance(
              format.frame_size.height(), format.frame_size.width(),
              constraint_set.height, constraint_set.width,
              constraint_set.aspectRatio, failed_constraint_name) +
          FrameRateConstraintSourceDistance(format.frame_rate,
                                            constraint_set.frameRate,
-                                           failed_constraint_name);
+                                           failed_constraint_name) +
+         StringConstraintSourceDistance(GetVideoKindForFormat(format),
+                                        constraint_set.videoKind,
+                                        failed_constraint_name);
 }
 
 // Returns a custom distance between a set of candidate settings and a
 // constraint set. It is simply the sum of the distances for each individual
 // setting in |candidate|.
 // If |candidate| cannot satisfy constraint, the distance is HUGE_VAL.
 // Otherwise the distance is a finite value. Candidates with lower distance
 // satisfy |constraint_set| in a "better" way.
 double CandidateSourceDistance(
     const VideoCaptureSourceSettings& candidate,
@@ skipping 149 matching lines @@
   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 += ResolutionConstraintFitnessDistance(candidate.GetHeight(),
                                                  constraint_set.height);
   fitness += ResolutionConstraintFitnessDistance(candidate.GetWidth(),
                                                  constraint_set.width);
 
   return fitness;
 }
 
@@ skipping 112 matching lines @@
 }
 
 double VideoCaptureSourceSettings::GetFrameRate() const {
   return format_.frame_rate;
 }
 
 blink::WebString VideoCaptureSourceSettings::GetDeviceId() const {
   return blink::WebString::fromASCII(device_id_.data());
 }
 
+blink::WebString VideoCaptureSourceSettings::GetVideoKind() const {
+  return GetVideoKindForFormat(format_);
+}
+
 const char kDefaultFailedConstraintName[] = "";
 
 VideoCaptureSourceSelectionResult::VideoCaptureSourceSelectionResult()
     : failed_constraint_name(kDefaultFailedConstraintName) {}
 VideoCaptureSourceSelectionResult::VideoCaptureSourceSelectionResult(
     const VideoCaptureSourceSelectionResult& other) = default;
 VideoCaptureSourceSelectionResult::VideoCaptureSourceSelectionResult(
     VideoCaptureSourceSelectionResult&& other) = default;
 VideoCaptureSourceSelectionResult::~VideoCaptureSourceSelectionResult() =
     default;
@@ skipping 101 matching lines @@
     }
   }
 
   if (!result.has_value())
     result.failed_constraint_name = failed_constraint_name;
 
   return result;
 }
 
 }  // namespace content