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 = 8192;

[miu, 2014/09/10 19:50:08]

This is a pretty huge window.  If RTT is updated every 1/2 second, this is 4096
seconds of history.

[hubbe, 2014/09/10 20:40:46]

changed to 1200 (10 minutes)

 
 }  // 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 109 matching lines @@
     VLOG_IF(1, is_last_aggressive_report) << "Sending last aggressive report.";
     SendRtcpReport(is_last_aggressive_report);
   }
 
   congestion_control_->SendFrameToTransport(
       frame_id, encoded_frame->data.size() * 8, last_send_time_);
 
   if (send_target_playout_delay_) {
     encoded_frame->new_playout_delay_ms =
         target_playout_delay_.InMilliseconds();
   }

[miu, 2014/09/10 19:50:08]

BTW--As I was poking around code recently, I noticed that there might be a
missing statement here:

  send_target_playout_delay_ = false;

[hubbe, 2014/09/10 20:40:46]

It's intentional.
If we allow frame dropping, then there is no guarantee that setting this on a
single packet will have any effect, so instead we set this on *every* packet.

   transport_sender_->InsertFrame(ssrc_, *encoded_frame);
 }
 
 void FrameSender::OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   const bool have_valid_rtt = current_round_trip_time_ > base::TimeDelta();
   if (have_valid_rtt) {
     congestion_control_->UpdateRtt(current_round_trip_time_);
 
@@ skipping 81 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