Cast: Reduce bitrate drastically when close to unacked frame limit

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 <cstring>
 #include <list>
 
 #include "base/bind.h"
@@ skipping 47 matching lines @@
       transport_sender_(transport_sender),
       event_subscriber_(kMaxEventSubscriberEntries),
       rtp_stats_(kVideoFrequency),
       rtcp_feedback_(new LocalRtcpVideoSenderFeedback(this)),
       last_acked_frame_id_(-1),
       last_sent_frame_id_(-1),
       frames_in_encoder_(0),
       duplicate_ack_(0),
       last_skip_count_(0),
       current_requested_bitrate_(video_config.start_bitrate),
+      current_bitrate_divider_(1),
       congestion_control_(cast_environment->Clock(),
                           video_config.congestion_control_back_off,
                           video_config.max_bitrate,
                           video_config.min_bitrate,
                           video_config.start_bitrate),
       initialized_(false),
       active_session_(false),
       weak_factory_(this) {
   max_unacked_frames_ =
       1 + static_cast<uint8>(video_config.rtp_config.max_delay_ms *
@@ skipping 99 matching lines @@
     VLOG(1) << "Send encoded key frame; frame_id:"
             << static_cast<int>(encoded_frame->frame_id);
   }
 
   DCHECK_GT(frames_in_encoder_, 0);
   frames_in_encoder_--;
   uint32 frame_id = encoded_frame->frame_id;
   cast_environment_->Logging()->InsertEncodedFrameEvent(
       last_send_time_, kVideoFrameEncoded, encoded_frame->rtp_timestamp,
       frame_id, static_cast<int>(encoded_frame->data.size()),
-      encoded_frame->key_frame, current_requested_bitrate_);
+      encoded_frame->key_frame,
+      current_requested_bitrate_);
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT1(
       "cast_perf_test", "VideoFrameEncoded",
       TRACE_EVENT_SCOPE_THREAD,
       "rtp_timestamp", GetVideoRtpTimestamp(capture_time));
 
   // Only use lowest 8 bits as key.
   frame_id_to_rtp_timestamp_[frame_id & 0xff] = encoded_frame->rtp_timestamp;
 
@@ skipping 182 matching lines @@
     int resend_frame = -1;
     if (last_sent_frame_id_ == -1)
       return;
 
     video_encoder_->LatestFrameIdToReference(cast_feedback.ack_frame_id_);
 
     if (static_cast<uint32>(last_acked_frame_id_ + 1) ==
         cast_feedback.ack_frame_id_) {
       uint32 new_bitrate = 0;
       if (congestion_control_.OnAck(rtt, &new_bitrate)) {
-        video_encoder_->SetBitRate(new_bitrate);
-        current_requested_bitrate_ = new_bitrate;
+        UpdateBitrate(new_bitrate);
       }
     }
     // We only count duplicate ACKs when we have sent newer frames.
     if (static_cast<uint32>(last_acked_frame_id_) ==
             cast_feedback.ack_frame_id_ &&
         IsNewerFrameId(last_sent_frame_id_, last_acked_frame_id_)) {
       duplicate_ack_++;
     } else {
       duplicate_ack_ = 0;
     }
     if (duplicate_ack_ >= 2 && duplicate_ack_ % 3 == 2) {
       // Resend last ACK + 1 frame.
       resend_frame = static_cast<uint32>(last_acked_frame_id_ + 1);
     }
     if (resend_frame != -1) {
       DCHECK_LE(0, resend_frame);
       VLOG(1) << "Received duplicate ACK for frame:"
               << static_cast<int>(resend_frame);
       ResendFrame(static_cast<uint32>(resend_frame));
     }
   } else {
     transport_sender_->ResendPackets(
         false, cast_feedback.missing_frames_and_packets_);
     uint32 new_bitrate = 0;
     if (congestion_control_.OnNack(rtt, &new_bitrate)) {
-      video_encoder_->SetBitRate(new_bitrate);
-      current_requested_bitrate_ = new_bitrate;
+      UpdateBitrate(new_bitrate);
     }
   }
   ReceivedAck(cast_feedback.ack_frame_id_);
 }
 
 void VideoSender::ReceivedAck(uint32 acked_frame_id) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (acked_frame_id == UINT32_C(0xFFFFFFFF)) {
     // Receiver is sending a status message before any frames are ready to
     // be acked. Ignore.
@@ skipping 15 matching lines @@
   VLOG(2) << "ReceivedAck:" << static_cast<int>(acked_frame_id);
   active_session_ = true;
   DCHECK_NE(-1, last_acked_frame_id_);
   UpdateFramesInFlight();
 }
 
 void VideoSender::UpdateFramesInFlight() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (last_sent_frame_id_ != -1) {
     DCHECK_LE(0, last_sent_frame_id_);
-    uint32 frames_in_flight = 0;
+    int frames_in_flight = 0;
     if (last_acked_frame_id_ != -1) {
       DCHECK_LE(0, last_acked_frame_id_);
-      frames_in_flight = static_cast<uint32>(last_sent_frame_id_) -
-                         static_cast<uint32>(last_acked_frame_id_);
+      frames_in_flight = last_sent_frame_id_ - last_acked_frame_id_;
     } else {
-      frames_in_flight = static_cast<uint32>(last_sent_frame_id_) + 1;
+      frames_in_flight = last_sent_frame_id_ + 1;
     }
     frames_in_flight += frames_in_encoder_;
     VLOG(2) << frames_in_flight
             << " Frames in flight; last sent: " << last_sent_frame_id_
             << " last acked:" << last_acked_frame_id_
             << " frames in encoder: " << frames_in_encoder_;
     if (frames_in_flight >= max_unacked_frames_) {
       video_encoder_->SkipNextFrame(true);
       return;
+    } else if (frames_in_flight > max_unacked_frames_ * 4 / 5) {
+      current_bitrate_divider_ = 3;
+    } else if (frames_in_flight > max_unacked_frames_ * 2 / 3) {
+      current_bitrate_divider_ = 2;
+    } else {
+      current_bitrate_divider_ = 1;
     }
     DCHECK(frames_in_flight <= max_unacked_frames_);
   }
   video_encoder_->SkipNextFrame(false);
 }
 
 void VideoSender::ResendFrame(uint32 resend_frame_id) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   MissingFramesAndPacketsMap missing_frames_and_packets;
   PacketIdSet missing;
   missing_frames_and_packets.insert(std::make_pair(resend_frame_id, missing));
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   transport_sender_->ResendPackets(false, missing_frames_and_packets);
 }
 
+void VideoSender::UpdateBitrate(int new_bitrate) {
+  new_bitrate /= current_bitrate_divider_;
+  // 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