Cast: First stab at implementing adaptive latency

media/cast/sender/frame_sender.cc

 // Copyright 2014 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 "media/cast/sender/frame_sender.h"
 
 #include "base/debug/trace_event.h"
 
 namespace media {
 namespace cast {
 namespace {
 
 const int kMinSchedulingDelayMs = 1;
 const int kNumAggressiveReportsSentAtStart = 100;
+const size_t kRTTWindow = 1200;
 
 }  // namespace
 
 FrameSender::FrameSender(scoped_refptr<CastEnvironment> cast_environment,
                          bool is_audio,
                          CastTransportSender* const transport_sender,
                          base::TimeDelta rtcp_interval,
                          int rtp_timebase,
                          uint32 ssrc,
                          double max_frame_rate,
-                         base::TimeDelta playout_delay,
+                         base::TimeDelta min_playout_delay,
+                         base::TimeDelta max_playout_delay,
                          CongestionControl* congestion_control)
     : cast_environment_(cast_environment),
       transport_sender_(transport_sender),
       ssrc_(ssrc),
       rtcp_interval_(rtcp_interval),
+      min_playout_delay_(min_playout_delay),
+      max_playout_delay_(max_playout_delay),
       max_frame_rate_(max_frame_rate),
       num_aggressive_rtcp_reports_sent_(0),
       last_sent_frame_id_(0),
       latest_acked_frame_id_(0),
       duplicate_ack_counter_(0),
       rtp_timebase_(rtp_timebase),
       congestion_control_(congestion_control),
       is_audio_(is_audio),
       weak_factory_(this) {
   DCHECK(transport_sender_);
   DCHECK_GT(rtp_timebase_, 0);
   DCHECK(congestion_control_);
-  SetTargetPlayoutDelay(playout_delay);
+  SetTargetPlayoutDelay(min_playout_delay);
   send_target_playout_delay_ = false;
   memset(frame_rtp_timestamps_, 0, sizeof(frame_rtp_timestamps_));
 }
 
 FrameSender::~FrameSender() {
 }
 
 void FrameSender::ScheduleNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeDelta time_to_next = rtcp_interval_;
@@ skipping 30 matching lines @@
           static_cast<uint32>(rtp_delta);
   transport_sender_->SendSenderReport(ssrc_, now, now_as_rtp_timestamp);
 
   if (schedule_future_reports)
     ScheduleNextRtcpReport();
 }
 
 void FrameSender::OnMeasuredRoundTripTime(base::TimeDelta rtt) {
   DCHECK(rtt > base::TimeDelta());
   current_round_trip_time_ = rtt;
+  recent_round_trip_times_.push_back(rtt);
+  recent_round_trip_times_sum_ += rtt;
+  if (recent_round_trip_times_.size() > kRTTWindow) {
+    recent_round_trip_times_sum_ -= recent_round_trip_times_[0];
+    recent_round_trip_times_.pop_front();
+  }
+}
+
+base::TimeDelta FrameSender::AverageRTT() {
+  return recent_round_trip_times_sum_ / recent_round_trip_times_.size();
 }
 
 void FrameSender::SetTargetPlayoutDelay(
     base::TimeDelta new_target_playout_delay) {
+  new_target_playout_delay = std::max(new_target_playout_delay,
+                                      min_playout_delay_);
+  new_target_playout_delay = std::min(new_target_playout_delay,
+                                      max_playout_delay_);
   target_playout_delay_ = new_target_playout_delay;
   max_unacked_frames_ =
       std::min(kMaxUnackedFrames,
                1 + static_cast<int>(target_playout_delay_ *
                                     max_frame_rate_ /
                                     base::TimeDelta::FromSeconds(1)));
   send_target_playout_delay_ = true;
 }
 
 void FrameSender::ResendCheck() {
@@ skipping 211 matching lines @@
           << duration_in_flight.InMicroseconds() << " usec ("
           << (target_playout_delay_ > base::TimeDelta() ?
                   100 * duration_in_flight / target_playout_delay_ :
                   kint64max) << "%)";
   return frames_in_flight >= max_unacked_frames_ ||
       duration_in_flight >= target_playout_delay_;
 }
 
 }  // namespace cast
 }  // namespace media