Cast: Updated congestion control

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 15 matching lines @@
 VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
     transport::CastTransportSender* const transport_sender)
     : cast_environment_(cast_environment),
       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_,
             NULL,  // paced sender.
             NULL,
             video_config.rtcp_mode,
             base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
             video_config.rtp_config.ssrc,
             video_config.incoming_feedback_ssrc,
             video_config.rtcp_c_name,
             VIDEO_EVENT),
       rtp_timestamp_helper_(kVideoFrequency),
       num_aggressive_rtcp_reports_sent_(0),
       frames_in_encoder_(0),
       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_;
   DCHECK_GT(max_unacked_frames_, 0);
 
   if (video_config.use_external_encoder) {
     video_encoder_.reset(new ExternalVideoEncoder(cast_environment,
                                                   video_config,
                                                   create_vea_cb,
                                                   create_video_encode_mem_cb));
@@ skipping 42 matching lines @@
       "cast_perf_test", "InsertRawVideoFrame",
       TRACE_EVENT_SCOPE_THREAD,
       "timestamp", capture_time.ToInternalValue(),
       "rtp_timestamp", rtp_timestamp);
 
   if (AreTooManyFramesInFlight()) {
     VLOG(1) << "Dropping frame due to too many frames currently in-flight.";
     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...";
   }
 }
 
 void VideoSender::SendEncodedVideoFrame(
     int requested_bitrate_before_encode,
     scoped_ptr<transport::EncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
@@ skipping 43 matching lines @@
   if (num_aggressive_rtcp_reports_sent_ < kNumAggressiveReportsSentAtStart) {
     // SendRtcpReport() will schedule future reports to be made if this is the
     // last "aggressive report."
     ++num_aggressive_rtcp_reports_sent_;
     const bool is_last_aggressive_report =
         (num_aggressive_rtcp_reports_sent_ == kNumAggressiveReportsSentAtStart);
     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_);
+
   transport_sender_->InsertCodedVideoFrame(*encoded_frame);
 }
 
 void VideoSender::IncomingRtcpPacket(scoped_ptr<Packet> packet) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   rtcp_.IncomingRtcpPacket(&packet->front(), packet->size());
 }
 
 void VideoSender::ScheduleNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
@@ skipping 59 matching lines @@
 }
 
 void VideoSender::OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   base::TimeDelta rtt;
   base::TimeDelta avg_rtt;
   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);
 
     // Having the RTT values implies the receiver sent back a receiver report
     // based on it having received a report from here.  Therefore, ensure this
     // sender stops aggressively sending reports.
     if (num_aggressive_rtcp_reports_sent_ < kNumAggressiveReportsSentAtStart) {
       VLOG(1) << "No longer a need to send reports aggressively (sent "
               << num_aggressive_rtcp_reports_sent_ << ").";
       num_aggressive_rtcp_reports_sent_ = kNumAggressiveReportsSentAtStart;
       ScheduleNextRtcpReport();
     }
   } else {
     // We have no measured value use default.
     rtt = base::TimeDelta::FromMilliseconds(kStartRttMs);
   }
 
   if (last_send_time_.is_null())
     return;  // Cannot get an ACK without having first sent a frame.
 
   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_) {
       duplicate_ack_counter_++;
     } else {
       duplicate_ack_counter_ = 0;
     }
     // TODO(miu): The values "2" and "3" should be derived from configuration.
     if (duplicate_ack_counter_ >= 2 && duplicate_ack_counter_ % 3 == 2) {
       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;
     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_ -
                              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)
     latest_acked_frame_id_ = cast_feedback.ack_frame_id_;
 }
 
@@ skipping 21 matching lines @@
   // packets and frames are missing.
   MissingFramesAndPacketsMap missing_frames_and_packets;
   PacketIdSet missing;
   missing.insert(0);
   missing_frames_and_packets.insert(
       std::make_pair(last_sent_frame_id_, missing));
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   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