[Cast] In Audio/VideoSender, drop frames when too-long a duration is in-flight.

media/cast/sender/video_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/video_sender.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
@@ skipping 108 matching lines @@
       rtp_timestamp,
       kFrameIdUnknown);
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT2(
       "cast_perf_test", "InsertRawVideoFrame",
       TRACE_EVENT_SCOPE_THREAD,
       "timestamp", capture_time.ToInternalValue(),
       "rtp_timestamp", rtp_timestamp);
 
-  if (AreTooManyFramesInFlight()) {
+  if (ShouldDropNextFrame(capture_time)) {
     VLOG(1) << "Dropping frame due to too many frames currently in-flight.";
     return;
   }
 
   uint32 bitrate = fixed_bitrate_;
   if (!bitrate) {
     bitrate = congestion_control_.GetBitrate(
         capture_time + target_playout_delay_, target_playout_delay_);
     DCHECK(bitrate);
     video_encoder_->SetBitRate(bitrate);
@@ skipping 27 matching lines @@
   const uint32 frame_id = encoded_frame->frame_id;
 
   const bool is_first_frame_to_be_sent = last_send_time_.is_null();
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   last_sent_frame_id_ = frame_id;
   // If this is the first frame about to be sent, fake the value of
   // |latest_acked_frame_id_| to indicate the receiver starts out all caught up.
   // Also, schedule the periodic frame re-send checks.
   if (is_first_frame_to_be_sent) {
     latest_acked_frame_id_ = frame_id - 1;
+    frame_id_to_rtp_timestamp_[latest_acked_frame_id_ & 0xff] =
+        encoded_frame->rtp_timestamp;
     ScheduleNextResendCheck();
   }
 
   VLOG_IF(1, encoded_frame->dependency == EncodedFrame::KEY)
       << "Send encoded key frame; frame_id: " << frame_id;
 
   cast_environment_->Logging()->InsertEncodedFrameEvent(
       last_send_time_, FRAME_ENCODED, VIDEO_EVENT, encoded_frame->rtp_timestamp,
       frame_id, static_cast<int>(encoded_frame->data.size()),
       encoded_frame->dependency == EncodedFrame::KEY,
@@ skipping 144 matching lines @@
     std::vector<uint32> cancel_sending_frames;
     while (latest_acked_frame_id_ != cast_feedback.ack_frame_id) {
       latest_acked_frame_id_++;
       cancel_sending_frames.push_back(latest_acked_frame_id_);
     }
     transport_sender_->CancelSendingFrames(ssrc_, cancel_sending_frames);
     latest_acked_frame_id_ = cast_feedback.ack_frame_id;
   }
 }
 
-bool VideoSender::AreTooManyFramesInFlight() const {
+bool VideoSender::ShouldDropNextFrame(base::TimeTicks capture_time) const {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  int frames_in_flight = frames_in_encoder_;
+  int frames_in_flight = 0;
+  int32 rtp_duration_in_flight = 0;
   if (!last_send_time_.is_null()) {
-    frames_in_flight +=
+    frames_in_flight =
         static_cast<int32>(last_sent_frame_id_ - latest_acked_frame_id_);
+    uint32 estimated_rtp_timestamp;
+    if (frames_in_flight > 0 &&
+        rtp_timestamp_helper_.EstimateRtpTimestamp(capture_time,
+                                                   &estimated_rtp_timestamp)) {
+      const uint32 oldest_unacked_frame_id = latest_acked_frame_id_ + 1;
+      rtp_duration_in_flight = static_cast<int32>(
+          estimated_rtp_timestamp -
+              frame_id_to_rtp_timestamp_[oldest_unacked_frame_id & 0xff]);
+    }
   }
+  frames_in_flight += frames_in_encoder_;
   VLOG(2) << frames_in_flight
           << " frames in flight; last sent: " << last_sent_frame_id_
-          << " latest acked: " << latest_acked_frame_id_
-          << " frames in encoder: " << frames_in_encoder_;
-  return frames_in_flight >= max_unacked_frames_;
+          << "; latest acked: " << latest_acked_frame_id_
+          << "; frames in encoder: " << frames_in_encoder_
+          << "; duration in flight: "
+          << (max_unacked_rtp_delta_ > 0 ?
+                  100 * rtp_duration_in_flight / max_unacked_rtp_delta_ :
+                  kint32max) << "%";
+  return frames_in_flight >= max_unacked_frames_ ||
+      rtp_duration_in_flight >= max_unacked_rtp_delta_;
 }
 
 void VideoSender::ResendForKickstart() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(!last_send_time_.is_null());
   VLOG(1) << "Resending last packet of frame " << last_sent_frame_id_
           << " to kick-start.";
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   transport_sender_->ResendFrameForKickstart(ssrc_, last_sent_frame_id_);
 }
 
 }  // namespace cast
 }  // namespace media