Remove command-line switch: cast-encoder-util-heuristic=backlog<N>

media/cast/sender/external_video_encoder.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/external_video_encoder.h"
 
 #include <cmath>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 
 enum { MAX_H264_QUANTIZER = 51 };
 
 // Number of buffers for encoded bit stream.
 constexpr size_t kOutputBufferCount = 3;
 
 // Maximum number of extra input buffers for encoder. The input buffers are only
 // used when copy is needed to match the required coded size.
 constexpr size_t kExtraInputBufferCount = 2;
 
-// Parses the command-line flag and returns 0 (default) to use the old/flawed
-// "deadline utilization" heuristic to measure encoder utilization. Otherwise,
-// returns the "redline" value for the "backlog" heuristic (i.e., num_frames /
-// redline = utilization).
-//
-// Example command line switches and results:
-//
-//   --cast-encoder-util-heuristic=foobar    ==> 0  (unrecognized, use deadline)
-//   --cast-encoder-util-heuristic=backlog   ==> 6  (use backlog, default)
-//   --cast-encoder-util-heuristic=backlog7  ==> 7  (use backlog, redline=7)
-//
-// TODO(miu): This is temporary, for lab performance testing, until a
-// good "works for all" solution is confirmed.
-// https://code.google.com/p/chrome-os-partner/issues/detail?id=54806
-int GetConfiguredBacklogRedline() {
-  constexpr char kBacklogSwitchValue[] = "backlog";
-  constexpr int kBacklogDefaultRedline = 6;
-
-  const std::string& switch_value =
-      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          switches::kCastEncoderUtilHeuristic);
-  if (!base::StartsWith(switch_value, kBacklogSwitchValue,
-                        base::CompareCase::SENSITIVE)) {
-    return 0;
-  }
-
-  int redline = kBacklogDefaultRedline;
-  if (!base::StringToInt(switch_value.substr(sizeof(kBacklogSwitchValue) - 1),
-                         &redline)) {
-    redline = kBacklogDefaultRedline;
-  }
-  VLOG(1) << "Using 'backlog' heuristic with a redline of " << redline
-          << " to compute encoder utilization.";
-  return redline;
-}
+// This value is used to calculate the encoder utilization. The encoder is
+// assumed to be in full usage when the number of frames in progress reaches it.
+constexpr int kBacklogRedlineThreshold = 4;
 
 }  // namespace
 
 namespace media {
 namespace cast {
 
 // Container for the associated data of a video frame being processed.
 struct InProgressFrameEncode {
   // The source content to encode.
   const scoped_refptr<VideoFrame> video_frame;
@@ skipping 37 matching lines @@
       std::unique_ptr<media::VideoEncodeAccelerator> vea,
       double max_frame_rate,
       const StatusChangeCallback& status_change_cb,
       const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb)
       : cast_environment_(cast_environment),
         task_runner_(encoder_task_runner),
         max_frame_rate_(max_frame_rate),
         status_change_cb_(status_change_cb),
         create_video_encode_memory_cb_(create_video_encode_memory_cb),
         video_encode_accelerator_(std::move(vea)),
-        backlog_redline_threshold_(GetConfiguredBacklogRedline()),
         encoder_active_(false),
         next_frame_id_(FrameId::first()),
         key_frame_encountered_(false),
         codec_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN),
         key_frame_quantizer_parsable_(false),
         requested_bit_rate_(-1),
         has_seen_zero_length_encoded_frame_(false),
         max_allowed_input_buffers_(0),
         allocate_input_buffer_in_progress_(false) {}
 
@@ skipping 191 matching lines @@
       }
       encoded_frame->data.append(
           static_cast<const char*>(output_buffer->memory()), payload_size);
 
       // If FRAME_DURATION metadata was provided in the source VideoFrame,
       // compute the utilization metrics.
       base::TimeDelta frame_duration;
       if (request.video_frame->metadata()->GetTimeDelta(
               media::VideoFrameMetadata::FRAME_DURATION, &frame_duration) &&
           frame_duration > base::TimeDelta()) {
-        if (backlog_redline_threshold_ == 0) {
-          // Compute encoder utilization as the real-world time elapsed divided
-          // by the frame duration.
-          const base::TimeDelta processing_time =
-              base::TimeTicks::Now() - request.start_time;
-          encoded_frame->encoder_utilization =
-              processing_time.InSecondsF() / frame_duration.InSecondsF();
-        } else {
-          // Compute encoder utilization in terms of the number of frames in
-          // backlog, including the current frame encode that is finishing
-          // here. This "backlog" model works as follows: First, assume that all
-          // frames utilize the encoder by the same amount. This is actually a
-          // false assumption, but it still works well because any frame that
-          // takes longer to encode will naturally cause the backlog to
-          // increase, and this will result in a higher computed utilization for
-          // the offending frame. If the backlog continues to increase, because
-          // the following frames are also taking too long to encode, the
-          // computed utilization for each successive frame will be higher. At
-          // some point, upstream control logic will decide that the data volume
-          // must be reduced.
-          encoded_frame->encoder_utilization =
-              static_cast<double>(in_progress_frame_encodes_.size()) /
-              backlog_redline_threshold_;
-        }
+        // Compute encoder utilization in terms of the number of frames in
+        // backlog, including the current frame encode that is finishing
+        // here. This "backlog" model works as follows: First, assume that all
+        // frames utilize the encoder by the same amount. This is actually a
+        // false assumption, but it still works well because any frame that
+        // takes longer to encode will naturally cause the backlog to
+        // increase, and this will result in a higher computed utilization for
+        // the offending frame. If the backlog continues to increase, because
+        // the following frames are also taking too long to encode, the
+        // computed utilization for each successive frame will be higher. At
+        // some point, upstream control logic will decide that the data volume
+        // must be reduced.
+        encoded_frame->encoder_utilization =
+            static_cast<double>(in_progress_frame_encodes_.size()) /
+            kBacklogRedlineThreshold;
 
         const double actual_bit_rate =
             encoded_frame->data.size() * 8.0 / frame_duration.InSecondsF();
         DCHECK_GT(request.target_bit_rate, 0);
         const double bitrate_utilization =
             actual_bit_rate / request.target_bit_rate;
         double quantizer = QuantizerEstimator::NO_RESULT;
         // If the quantizer can be parsed from the key frame, try to parse
         // the following delta frames as well.
         // Otherwise, switch back to entropy estimation for the key frame
@@ skipping 207 matching lines @@
     }
     return (num_slices == 0) ? -1 : (total_quantizer / num_slices);
   }
 
   const scoped_refptr<CastEnvironment> cast_environment_;
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   const double max_frame_rate_;
   const StatusChangeCallback status_change_cb_;  // Must be run on MAIN thread.
   const CreateVideoEncodeMemoryCallback create_video_encode_memory_cb_;
   std::unique_ptr<media::VideoEncodeAccelerator> video_encode_accelerator_;
-  const int backlog_redline_threshold_;
   bool encoder_active_;
   FrameId next_frame_id_;
   bool key_frame_encountered_;
   std::string stream_header_;
   VideoCodecProfile codec_profile_;
   bool key_frame_quantizer_parsable_;
   H264Parser h264_parser_;
 
   // Shared memory buffers for output with the VideoAccelerator.
   std::vector<std::unique_ptr<base::SharedMemory>> output_buffers_;
@@ skipping 341 matching lines @@
   const double kEntropyAtMaxQuantizer = 7.5;
   const double slope =
       (MAX_VP8_QUANTIZER - MIN_VP8_QUANTIZER) / kEntropyAtMaxQuantizer;
   const double quantizer = std::min<double>(
       MAX_VP8_QUANTIZER, MIN_VP8_QUANTIZER + slope * shannon_entropy);
   return quantizer;
 }
 
 }  //  namespace cast
 }  //  namespace media