Add framerate to VideoSinkWants and ability to signal on overuse

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.
  */
 
@@ skipping 88 matching lines @@
 
 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()) {}
+      resolution_request_max_pixel_count_(std::numeric_limits<int>::max()),
+      max_framerate_request_(std::numeric_limits<int>::max()) {}
 
 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)
+  if (max_framerate_request_ <= 0)
+    return false;
+
+  int64_t frame_interval_ns =
+      requested_format_ ? requested_format_->interval : 0;
+
+  // If |max_framerate_request_| is not set, it will default to maxint, which
+  // will lead to a frame_interval_ns rounded to 0.
+  frame_interval_ns = std::max<int64_t>(
+      frame_interval_ns, rtc::kNumNanosecsPerSec / max_framerate_request_);
+
+  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) {
@@ skipping 91 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(
+void VideoAdapter::OnResolutionFramerateRequest(
     const rtc::Optional<int>& target_pixel_count,
-    const rtc::Optional<int>& max_pixel_count) {
+    const rtc::Optional<int>& max_pixel_count,
+    const rtc::Optional<int>& framerate_fps) {

[nisse-webrtc, 2017/03/14 09:00:28]

Even if you want to keep optional in the SinkWants struct for now,
please drop it from the two max values here, and move the value_or(INT_MAX)
logic to the caller.

Use of optional for const function arguments is discouraged, so at some point
you may want to change target_pixel_count to const int* too, but that's a
borderline case.

[sprang_webrtc, 2017/03/14 14:15:02]

Removed optional everywhere for max_pixel and fps. Kept target as optional for
now.

   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_);
+  max_framerate_request_ =
+      framerate_fps.value_or(std::numeric_limits<int>::max());
 }
 
 }  // namespace cricket