Add sender controlled playout delay limits

webrtc/modules/video_coding/timing.cc

 /*
  *  Copyright (c) 2011 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 10 matching lines @@
 namespace webrtc {
 
 VCMTiming::VCMTiming(Clock* clock, VCMTiming* master_timing)
     : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
       clock_(clock),
       master_(false),
       ts_extrapolator_(),
       codec_timer_(new VCMCodecTimer()),
       render_delay_ms_(kDefaultRenderDelayMs),
       min_playout_delay_ms_(0),
+      max_playout_delay_ms_(10000),
       jitter_delay_ms_(0),
       current_delay_ms_(0),
       last_decode_ms_(0),
       prev_frame_timestamp_(0),
       num_decoded_frames_(0),
       num_delayed_decoded_frames_(0),
       first_decoded_frame_ms_(-1),
       sum_missed_render_deadline_ms_(0) {
   if (master_timing == NULL) {
     master_ = true;
@@ skipping 53 matching lines @@
 void VCMTiming::set_render_delay(uint32_t render_delay_ms) {
   CriticalSectionScoped cs(crit_sect_);
   render_delay_ms_ = render_delay_ms;
 }
 
 void VCMTiming::set_min_playout_delay(uint32_t min_playout_delay_ms) {
   CriticalSectionScoped cs(crit_sect_);
   min_playout_delay_ms_ = min_playout_delay_ms;
 }
 
+uint32_t VCMTiming::min_playout_delay() {
+  CriticalSectionScoped cs(crit_sect_);
+  return min_playout_delay_ms_;
+}
+
+void VCMTiming::set_max_playout_delay(uint32_t max_playout_delay_ms) {
+  CriticalSectionScoped cs(crit_sect_);
+  max_playout_delay_ms_ = max_playout_delay_ms;
+}
+
+uint32_t VCMTiming::max_playout_delay() {
+  CriticalSectionScoped cs(crit_sect_);
+  return max_playout_delay_ms_;
+}
+
 void VCMTiming::SetJitterDelay(uint32_t jitter_delay_ms) {
   CriticalSectionScoped cs(crit_sect_);
   if (jitter_delay_ms != jitter_delay_ms_) {
     jitter_delay_ms_ = jitter_delay_ms;
     // When in initial state, set current delay to minimum delay.
     if (current_delay_ms_ == 0) {
       current_delay_ms_ = jitter_delay_ms_;
     }
   }
 }
@@ skipping 90 matching lines @@
 }
 
 int64_t VCMTiming::RenderTimeMsInternal(uint32_t frame_timestamp,
                                         int64_t now_ms) const {
   int64_t estimated_complete_time_ms =
       ts_extrapolator_->ExtrapolateLocalTime(frame_timestamp);
   if (estimated_complete_time_ms == -1) {
     estimated_complete_time_ms = now_ms;
   }
 
-  // Make sure that we have at least the playout delay.
+  if (min_playout_delay_ms_ == 0 && max_playout_delay_ms_ == 0) {
+    // Render as soon as possible
+    return now_ms;
+  }
+
+  // Make sure the actual delay stays in the range of |min_playout_delay_ms_|
+  // and |max_playout_delay_ms_|.
   uint32_t actual_delay = std::max(current_delay_ms_, min_playout_delay_ms_);
+  actual_delay = std::min(actual_delay, max_playout_delay_ms_);
   return estimated_complete_time_ms + actual_delay;
 }
 
 // Must be called from inside a critical section.
 int64_t VCMTiming::RequiredDecodeTimeMs() const {
   const int64_t decode_time_ms = codec_timer_->RequiredDecodeTimeMs();
   assert(decode_time_ms >= 0);
   return decode_time_ms;
 }
 
@@ skipping 51 matching lines @@
   *decode_ms = last_decode_ms_;
   *max_decode_ms = static_cast<int>(RequiredDecodeTimeMs());
   *current_delay_ms = current_delay_ms_;
   *target_delay_ms = TargetDelayInternal();
   *jitter_buffer_ms = jitter_delay_ms_;
   *min_playout_delay_ms = min_playout_delay_ms_;
   *render_delay_ms = render_delay_ms_;
 }
 
 }  // namespace webrtc