Cast: Use fixed bitrate and set it once for hardware encoder

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"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/sender/external_video_encoder.h"
 #include "media/cast/sender/video_encoder_impl.h"
 
 namespace media {
 namespace cast {
 
 const int kNumAggressiveReportsSentAtStart = 100;
 const int kMinSchedulingDelayMs = 1;
 
+namespace {
+
+// Returns a fixed bitrate value when external video encoder is used.
+// Some hardware encoder shows bad behavior if we set the bitrate too
+// frequently, e.g. quality drop, not abiding by target bitrate, etc.
+// See details: crbug.com/392086.
+size_t GetFixedBitrate(const VideoSenderConfig& video_config) {
+  if (!video_config.use_external_encoder)
+    return 0;
+  return (video_config.min_bitrate + video_config.max_bitrate) / 2;
+}
+
+}  // namespace
+
 VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
     CastTransportSender* const transport_sender)
     : FrameSender(
         cast_environment,
         transport_sender,
         base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
         kVideoFrequency,
         video_config.ssrc),
       target_playout_delay_(video_config.target_playout_delay),
       max_unacked_frames_(
           std::min(kMaxUnackedFrames,
                    1 + static_cast<int>(target_playout_delay_ *
                                         video_config.max_frame_rate /
                                         base::TimeDelta::FromSeconds(1)))),
+      fixed_bitrate_(GetFixedBitrate(video_config)),
       num_aggressive_rtcp_reports_sent_(0),
       frames_in_encoder_(0),
       last_sent_frame_id_(0),
       latest_acked_frame_id_(0),
       duplicate_ack_counter_(0),
       congestion_control_(cast_environment->Clock(),
                           video_config.max_bitrate,
                           video_config.min_bitrate,
                           max_unacked_frames_),
       cast_initialization_status_(STATUS_VIDEO_UNINITIALIZED),
@@ skipping 57 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);
+  uint32 bitrate = fixed_bitrate_;

[miu, 2014/08/05 21:52:07]

nit/bike-shedding: How about killing the extra |bitrate| variable to help
readability?  Meaning:

  if (!fixed_bitrate_) {
    video_encoder_->SetBitRate(congestion_control_.GetBitrate(
        capture_time + target_playout_delay_, target_playout_delay_));
  } else if (last_send_time_.is_null()) {
    // ...comment here...
    video_encoder_->SetBitRate(fixed_bitrate_);
  }

[Alpha Left Google, 2014/08/06 01:24:54]

bitrate is used in line 153.

+  if (!bitrate) {
+    bitrate = congestion_control_.GetBitrate(
+        capture_time + target_playout_delay_, target_playout_delay_);
+    DCHECK(bitrate);
+    video_encoder_->SetBitRate(bitrate);
+  } else if (last_send_time_.is_null()) {
+    // Set the fixed bitrate value to codec until a frame is sent. We might
+    // set this value a couple times at the very beginning of the stream but
+    // it is not harmful.
+    video_encoder_->SetBitRate(bitrate);
+  }
 
   if (video_encoder_->EncodeVideoFrame(
           video_frame,
           capture_time,
           base::Bind(&VideoSender::SendEncodedVideoFrame,
                      weak_factory_.GetWeakPtr(),
                      bitrate))) {
     frames_in_encoder_++;
   } else {
     VLOG(1) << "Encoder rejected a frame.  Skipping...";
@@ skipping 214 matching lines @@
   last_send_time_ = cast_environment_->Clock()->NowTicks();
 
   // 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, rtt_);
 }
 
 }  // namespace cast
 }  // namespace media