Cast: Avoid retransmit if we sent the same packet recently (less than RTT)

media/cast/video_sender/video_sender.cc

 // Copyright 2013 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/video_sender/video_sender.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
@@ skipping 303 matching lines @@
       VLOG(1) << "Received duplicate ACK for frame " << latest_acked_frame_id_;
       ResendForKickstart();
     }
   } else {
     // Only count duplicated ACKs if there is no NACK request in between.
     // This is to avoid aggresive resend.
     duplicate_ack_counter_ = 0;
 
     // A NACK is also used to cancel pending re-transmissions.
     transport_sender_->ResendPackets(
-        false, cast_feedback.missing_frames_and_packets_, true);
+        false, cast_feedback.missing_frames_and_packets_, true, rtt);
   }
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   congestion_control_.AckFrame(cast_feedback.ack_frame_id_, now);
 
   RtpTimestamp rtp_timestamp =
       frame_id_to_rtp_timestamp_[cast_feedback.ack_frame_id_ & 0xff];
   cast_environment_->Logging()->InsertFrameEvent(now,
                                                  FRAME_ACK_RECEIVED,
                                                  VIDEO_EVENT,
                                                  rtp_timestamp,
                                                  cast_feedback.ack_frame_id_);
 
   const bool is_acked_out_of_order =
       static_cast<int32>(cast_feedback.ack_frame_id_ -
                              latest_acked_frame_id_) < 0;
   VLOG(2) << "Received ACK" << (is_acked_out_of_order ? " out-of-order" : "")
           << " for frame " << cast_feedback.ack_frame_id_;
   if (!is_acked_out_of_order) {
     // Cancel resends of acked frames.
     MissingFramesAndPacketsMap missing_frames_and_packets;
     PacketIdSet missing;
     while (latest_acked_frame_id_ != cast_feedback.ack_frame_id_) {
       latest_acked_frame_id_++;
       missing_frames_and_packets[latest_acked_frame_id_] = missing;
     }
-    transport_sender_->ResendPackets(false, missing_frames_and_packets, true);
+    transport_sender_->ResendPackets(
+        false, missing_frames_and_packets, true, rtt);
     latest_acked_frame_id_ = cast_feedback.ack_frame_id_;
   }
 }
 
 bool VideoSender::AreTooManyFramesInFlight() const {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   int frames_in_flight = frames_in_encoder_;
   if (!last_send_time_.is_null()) {
     frames_in_flight +=
         static_cast<int32>(last_sent_frame_id_ - latest_acked_frame_id_);
@@ skipping 13 matching lines @@
   // Send the first packet of the last encoded frame to kick start
   // retransmission. This gives enough information to the receiver what
   // packets and frames are missing.
   MissingFramesAndPacketsMap missing_frames_and_packets;
   PacketIdSet missing;
   missing.insert(kRtcpCastLastPacket);
   missing_frames_and_packets.insert(
       std::make_pair(last_sent_frame_id_, missing));
   last_send_time_ = cast_environment_->Clock()->NowTicks();
 
+  base::TimeDelta rtt;
+  base::TimeDelta avg_rtt;
+  base::TimeDelta min_rtt;
+  base::TimeDelta max_rtt;
+  rtcp_.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt);
+
   // Sending this extra packet is to kick-start the session. There is
   // no need to optimize re-transmission for this case.
   transport_sender_->ResendPackets(false, missing_frames_and_packets,
-                                   false);
+                                   false, avg_rtt);

[Alpha Left Google, 2014/06/18 01:43:32]

We use rtt in other places why using avg_rtt here?

[hubbe, 2014/06/18 20:22:28]

Done.

 }
 
 }  // namespace cast
 }  // namespace media