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>
@@ skipping 12 matching lines @@
 // device ID, power-line frequency, resolution and frame rate.
 const int kNumDefaultDistanceEntries = 4;
 
 // The default resolution to be preferred as tie-breaking criterion.
 const int kDefaultResolutionArea = MediaStreamVideoSource::kDefaultWidth *
                                    MediaStreamVideoSource::kDefaultHeight;
 
 // The minimum aspect ratio to be supported by sources.
 const double kMinSourceAspectRatio = 0.05;
 
+// VideoKind enum values. See https://w3c.github.io/mediacapture-depth.
+const char kVideoKindColor[] = "color";
+const char kVideoKindDepth[] = "depth";
+
 blink::WebString ToWebString(::mojom::FacingMode facing_mode) {
   switch (facing_mode) {
     case ::mojom::FacingMode::USER:
       return blink::WebString::fromASCII("user");
     case ::mojom::FacingMode::ENVIRONMENT:
       return blink::WebString::fromASCII("environment");
     case ::mojom::FacingMode::LEFT:
       return blink::WebString::fromASCII("left");
     case ::mojom::FacingMode::RIGHT:
       return blink::WebString::fromASCII("right");
@@ skipping 257 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 57 matching lines @@
   double frame_rate_distance =
       candidate.format().frame_rate == MediaStreamVideoSource::kDefaultFrameRate
           ? 0.0
           : Distance(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);
+}
+
 VideoCaptureCapabilities::VideoCaptureCapabilities() = default;
 VideoCaptureCapabilities::VideoCaptureCapabilities(
     VideoCaptureCapabilities&& other) = default;
 VideoCaptureCapabilities::~VideoCaptureCapabilities() = default;
 VideoCaptureCapabilities& VideoCaptureCapabilities::operator=(
     VideoCaptureCapabilities&& other) = default;
 
 VideoCaptureSourceSettings::VideoCaptureSourceSettings(
     const VideoCaptureSourceSettings& other) = default;
 VideoCaptureSourceSettings::VideoCaptureSourceSettings(
@@ skipping 35 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