Update sink wants with ranges for both pixel count and frame rate.

webrtc/media/base/videoadapter.cc

 /*
  *  Copyright (c) 2010 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/media/base/videoadapter.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstdlib>
 #include <limits>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/optional.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/videocommon.h"
+#include "webrtc/media/base/videosourceinterface.h"
 
 namespace {
 struct Fraction {
-  int numerator;
-  int denominator;
+  uint32_t numerator;
+  uint32_t denominator;
 
   // Determines number of output pixels if both width and height of an input of
   // |input_pixels| pixels is scaled with the fraction numerator / denominator.
-  int scale_pixel_count(int input_pixels) {
+  uint32_t scale_pixel_count(uint32_t input_pixels) {
     return (numerator * numerator * input_pixels) / (denominator * denominator);
   }
 };
 
 // Round |value_to_round| to a multiple of |multiple|. Prefer rounding upwards,
 // but never more than |max_value|.
 int roundUp(int value_to_round, int multiple, int max_value) {
   const int rounded_value =
       (value_to_round + multiple - 1) / multiple * multiple;
   return rounded_value <= max_value ? rounded_value
                                     : (max_value / multiple * multiple);
 }
 
 // Generates a scale factor that makes |input_pixels| close to |target_pixels|,
 // but no higher than |max_pixels|.
-Fraction FindScale(int input_pixels, int target_pixels, int max_pixels) {
+Fraction FindScale(uint32_t input_pixels,
+                   uint32_t target_pixels,
+                   uint32_t max_pixels,
+                   uint32_t min_pixels) {
   // This function only makes sense for a positive target.
   RTC_DCHECK_GT(target_pixels, 0);
   RTC_DCHECK_GT(max_pixels, 0);
   RTC_DCHECK_GE(max_pixels, target_pixels);
 
   // Don't scale up original.
   if (target_pixels >= input_pixels)
     return Fraction{1, 1};
 
   Fraction current_scale = Fraction{1, 1};
   Fraction best_scale = Fraction{1, 1};
   // The minimum (absolute) difference between the number of output pixels and
   // the target pixel count.
-  int min_pixel_diff = std::numeric_limits<int>::max();
+  uint32_t min_pixel_diff = std::numeric_limits<uint32_t>::max();
   if (input_pixels < max_pixels) {
     // Start condition for 1/1 case, if it is less than max.
-    min_pixel_diff = std::abs(input_pixels - target_pixels);
+    min_pixel_diff = target_pixels > input_pixels
+                         ? target_pixels - input_pixels
+                         : input_pixels - target_pixels;
   }
 
   // Alternately scale down by 2/3 and 3/4. This results in fractions which are
   // effectively scalable. For instance, starting at 1280x720 will result in
   // the series (3/4) => 960x540, (1/2) => 640x360, (3/8) => 480x270,
   // (1/4) => 320x180, (3/16) => 240x125, (1/8) => 160x90.
   while (current_scale.scale_pixel_count(input_pixels) > target_pixels) {
     if (current_scale.numerator % 3 == 0 &&
         current_scale.denominator % 2 == 0) {
       // Multiply by 2/3.
       current_scale.numerator /= 3;
       current_scale.denominator /= 2;
     } else {
       // Multiply by 3/4.
       current_scale.numerator *= 3;
       current_scale.denominator *= 4;
     }
 
-    int output_pixels = current_scale.scale_pixel_count(input_pixels);
+    uint32_t output_pixels = current_scale.scale_pixel_count(input_pixels);
+    if (output_pixels < min_pixels) {
+      // Don't violate lower bound;
+      break;
+    }
     if (output_pixels <= max_pixels) {
-      int diff = std::abs(target_pixels - output_pixels);
+      uint32_t diff = target_pixels < output_pixels
+                          ? output_pixels - target_pixels
+                          : target_pixels - output_pixels;
       if (diff < min_pixel_diff) {
         min_pixel_diff = diff;
         best_scale = current_scale;
       }
     }
   }
 
   return best_scale;
 }
 }  // namespace
 
 namespace cricket {
 
 VideoAdapter::VideoAdapter(int required_resolution_alignment)
     : frames_in_(0),
       frames_out_(0),
       frames_scaled_(0),
       adaption_changes_(0),
       previous_width_(0),
       previous_height_(0),
-      required_resolution_alignment_(required_resolution_alignment),
-      resolution_request_target_pixel_count_(std::numeric_limits<int>::max()),
-      resolution_request_max_pixel_count_(std::numeric_limits<int>::max()) {}
+      required_resolution_alignment_(required_resolution_alignment) {}
 
 VideoAdapter::VideoAdapter() : VideoAdapter(1) {}
 
 VideoAdapter::~VideoAdapter() {}
 
 bool VideoAdapter::KeepFrame(int64_t in_timestamp_ns) {
   rtc::CritScope cs(&critical_section_);
-  if (!requested_format_ || requested_format_->interval == 0)
+
+  int64_t frame_interval_ns = 0;
+  if (requested_format_ && requested_format_->interval)
+    frame_interval_ns = requested_format_->interval;
+  // TODO(sprang): Take target/min into consideration when implementing smoother
+  // frame dropping.
+  if (requested_framerate_fps_) {
+    frame_interval_ns = std::max<int64_t>(
+        frame_interval_ns,
+        rtc::kNumNanosecsPerSec / requested_framerate_fps_->max);
+  }
+
+  if (frame_interval_ns <= 0) {
+    // Frame rate throttling not enabled.
     return true;
+  }
 
   if (next_frame_timestamp_ns_) {
     // Time until next frame should be outputted.
     const int64_t time_until_next_frame_ns =
         (*next_frame_timestamp_ns_ - in_timestamp_ns);
 
-    // Continue if timestamp is withing expected range.
-    if (std::abs(time_until_next_frame_ns) < 2 * requested_format_->interval) {
+    // Continue if timestamp is within expected range.
+    if (std::abs(time_until_next_frame_ns) < 2 * frame_interval_ns) {
       // Drop if a frame shouldn't be outputted yet.
       if (time_until_next_frame_ns > 0)
         return false;
       // Time to output new frame.
-      *next_frame_timestamp_ns_ += requested_format_->interval;
+      *next_frame_timestamp_ns_ += frame_interval_ns;
       return true;
     }
   }
 
   // First timestamp received or timestamp is way outside expected range, so
   // reset. Set first timestamp target to just half the interval to prefer
   // keeping frames in case of jitter.
   next_frame_timestamp_ns_ =
-      rtc::Optional<int64_t>(in_timestamp_ns + requested_format_->interval / 2);
+      rtc::Optional<int64_t>(in_timestamp_ns + frame_interval_ns / 2);
   return true;
 }
 
 bool VideoAdapter::AdaptFrameResolution(int in_width,
                                         int in_height,
                                         int64_t in_timestamp_ns,
                                         int* cropped_width,
                                         int* cropped_height,
                                         int* out_width,
                                         int* out_height) {
   rtc::CritScope cs(&critical_section_);
   ++frames_in_;
 
   // The max output pixel count is the minimum of the requests from
   // OnOutputFormatRequest and OnResolutionRequest.
-  int max_pixel_count = resolution_request_max_pixel_count_;
+
+  rtc::VideoSinkWants::Range requested_range =
+      requested_pixel_count_.value_or(rtc::VideoSinkWants::Range());
+  RTC_DCHECK_GE(requested_range.target, requested_range.min);
+  RTC_DCHECK_GE(requested_range.max, requested_range.target);
+  uint32_t max_pixel_count = requested_range.max;
   if (requested_format_) {
     max_pixel_count = std::min(
-        max_pixel_count, requested_format_->width * requested_format_->height);
+        max_pixel_count, static_cast<uint32_t>(requested_format_->width *
+                                               requested_format_->height));
   }
-  int target_pixel_count =
-      std::min(resolution_request_target_pixel_count_, max_pixel_count);
+  uint32_t target_pixel_count =
+      std::min(requested_range.target, max_pixel_count);
 
   // Drop the input frame if necessary.
   if (max_pixel_count <= 0 || !KeepFrame(in_timestamp_ns)) {
     // Show VAdapt log every 90 frames dropped. (3 seconds)
     if ((frames_in_ - frames_out_) % 90 == 0) {
       // TODO(fbarchard): Reduce to LS_VERBOSE when adapter info is not needed
       // in default calls.
       LOG(LS_INFO) << "VAdapt Drop Frame: scaled " << frames_scaled_
                    << " / out " << frames_out_
                    << " / in " << frames_in_
@@ skipping 21 matching lines @@
       std::swap(requested_format_->width, requested_format_->height);
     }
     const float requested_aspect =
         requested_format_->width /
         static_cast<float>(requested_format_->height);
     *cropped_width =
         std::min(in_width, static_cast<int>(in_height * requested_aspect));
     *cropped_height =
         std::min(in_height, static_cast<int>(in_width / requested_aspect));
   }
-  const Fraction scale = FindScale((*cropped_width) * (*cropped_height),
-                                   target_pixel_count, max_pixel_count);
+  const Fraction scale =
+      FindScale((*cropped_width) * (*cropped_height), target_pixel_count,
+                max_pixel_count, requested_range.min);
   // Adjust cropping slightly to get even integer output size and a perfect
   // scale factor. Make sure the resulting dimensions are aligned correctly
   // to be nice to hardware encoders.
   *cropped_width =
       roundUp(*cropped_width,
               scale.denominator * required_resolution_alignment_, in_width);
   *cropped_height =
       roundUp(*cropped_height,
               scale.denominator * required_resolution_alignment_, in_height);
   RTC_DCHECK_EQ(0, *cropped_width % scale.denominator);
@@ skipping 26 matching lines @@
 
   return true;
 }
 
 void VideoAdapter::OnOutputFormatRequest(const VideoFormat& format) {
   rtc::CritScope cs(&critical_section_);
   requested_format_ = rtc::Optional<VideoFormat>(format);
   next_frame_timestamp_ns_ = rtc::Optional<int64_t>();
 }
 
-void VideoAdapter::OnResolutionRequest(
-    const rtc::Optional<int>& target_pixel_count,
-    const rtc::Optional<int>& max_pixel_count) {
+void VideoAdapter::OnResolutionFramerateRequest(
+    const rtc::Optional<rtc::VideoSinkWants::Range>& pixel_count,
+    const rtc::Optional<rtc::VideoSinkWants::Range>& framerate_fps) {
   rtc::CritScope cs(&critical_section_);
-  resolution_request_max_pixel_count_ =
-      max_pixel_count.value_or(std::numeric_limits<int>::max());
-  resolution_request_target_pixel_count_ =
-      target_pixel_count.value_or(resolution_request_max_pixel_count_);
+  requested_pixel_count_ = pixel_count;
+  requested_framerate_fps_ = framerate_fps;
 }
 
 }  // namespace cricket