Cast: Updated congestion control

media/cast/video_sender/video_sender.cc

Index: media/cast/video_sender/video_sender.cc
diff --git a/media/cast/video_sender/video_sender.cc b/media/cast/video_sender/video_sender.cc
index f228c1b3d1af1cedc5d376e41b690a5345132a79..85b45c6db6107a69ae9e3c5fdfbe810228b55eaa 100644
--- a/media/cast/video_sender/video_sender.cc
+++ b/media/cast/video_sender/video_sender.cc
@@ -33,11 +33,11 @@ VideoSender::VideoSender(
       target_playout_delay_(base::TimeDelta::FromMilliseconds(
           video_config.rtp_config.max_delay_ms)),
       transport_sender_(transport_sender),
-      max_unacked_frames_(std::min(
-          kMaxUnackedFrames,
-          1 + static_cast<int>(
-              target_playout_delay_ * video_config.max_frame_rate /
-                  base::TimeDelta::FromSeconds(1)))),
+      max_unacked_frames_(
+          std::min(kMaxUnackedFrames,
+                   1 + static_cast<int>(target_playout_delay_ *
+                                        video_config.max_frame_rate /
+                                        base::TimeDelta::FromSeconds(1)))),
       rtcp_(cast_environment_,
             this,
             transport_sender_,
@@ -55,12 +55,10 @@ VideoSender::VideoSender(
       last_sent_frame_id_(0),
       latest_acked_frame_id_(0),
       duplicate_ack_counter_(0),
-      current_requested_bitrate_(video_config.start_bitrate),
       congestion_control_(cast_environment->Clock(),
-                          video_config.congestion_control_back_off,
                           video_config.max_bitrate,
                           video_config.min_bitrate,
-                          video_config.start_bitrate),
+                          max_unacked_frames_),
       cast_initialization_status_(STATUS_VIDEO_UNINITIALIZED),
       weak_factory_(this) {
   VLOG(1) << "max_unacked_frames " << max_unacked_frames_;
@@ -123,12 +121,17 @@ void VideoSender::InsertRawVideoFrame(
     return;
   }
 
+  uint32 bitrate = congestion_control_.GetBitrate(
+      capture_time + target_playout_delay_, target_playout_delay_);
+
+  video_encoder_->SetBitRate(bitrate);
+
   if (video_encoder_->EncodeVideoFrame(
           video_frame,
           capture_time,
           base::Bind(&VideoSender::SendEncodedVideoFrame,
                      weak_factory_.GetWeakPtr(),
-                     current_requested_bitrate_))) {
+                     bitrate))) {
     frames_in_encoder_++;
   } else {
     VLOG(1) << "Encoder rejected a frame.  Skipping...";
@@ -192,6 +195,9 @@ void VideoSender::SendEncodedVideoFrame(
     SendRtcpReport(is_last_aggressive_report);
   }
 
+  congestion_control_.SendFrameToTransport(
+      frame_id, encoded_frame->data.size() * 8, last_send_time_);
+
   transport_sender_->InsertCodedVideoFrame(*encoded_frame);
 }
 
@@ -271,6 +277,8 @@ void VideoSender::OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback) {
   base::TimeDelta min_rtt;
   base::TimeDelta max_rtt;
   if (rtcp_.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)) {
+    congestion_control_.UpdateRTT(rtt);
+
     // Don't use a RTT lower than our average.
     rtt = std::max(rtt, avg_rtt);
 
@@ -294,12 +302,6 @@ void VideoSender::OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback) {
   if (cast_feedback.missing_frames_and_packets_.empty()) {
     video_encoder_->LatestFrameIdToReference(cast_feedback.ack_frame_id_);
 
-    if ((latest_acked_frame_id_ + 1) == cast_feedback.ack_frame_id_) {
-      uint32 new_bitrate = 0;
-      if (congestion_control_.OnAck(rtt, &new_bitrate)) {
-        UpdateBitrate(new_bitrate);
-      }
-    }
     // We only count duplicate ACKs when we have sent newer frames.
     if (latest_acked_frame_id_ == cast_feedback.ack_frame_id_ &&
         latest_acked_frame_id_ != last_sent_frame_id_) {
@@ -318,17 +320,18 @@ void VideoSender::OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback) {
     duplicate_ack_counter_ = 0;
     transport_sender_->ResendPackets(
         false, cast_feedback.missing_frames_and_packets_);
-    uint32 new_bitrate = 0;
-    if (congestion_control_.OnNack(rtt, &new_bitrate)) {
-      UpdateBitrate(new_bitrate);
-    }
   }
 
+  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(
-      cast_environment_->Clock()->NowTicks(), FRAME_ACK_RECEIVED, VIDEO_EVENT,
-      rtp_timestamp, cast_feedback.ack_frame_id_);
+  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_ -
@@ -370,12 +373,5 @@ void VideoSender::ResendForKickstart() {
   transport_sender_->ResendPackets(false, missing_frames_and_packets);
 }
 
-void VideoSender::UpdateBitrate(int new_bitrate) {
-  // Make sure we don't set the bitrate too insanely low.
-  DCHECK_GT(new_bitrate, 1000);
-  video_encoder_->SetBitRate(new_bitrate);
-  current_requested_bitrate_ = new_bitrate;
-}
-
 }  // namespace cast
 }  // namespace media