media/cast/sender: Rename deadline_utilization to encoder_utilization.

media/cast/sender/vp8_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/vp8_encoder.h"
 
 #include "base/debug/crash_logging.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 13 matching lines @@
 // pause in the video stream.
 const int kRestartFramePeriods = 3;
 
 // The following constants are used to automactically tune the encoder
 // parameters: |cpu_used| and |min_quantizer|.
 
 // The |half-life| of the encoding speed accumulator.
 // The smaller, the shorter of the time averaging window.
 const int kEncodingSpeedAccHalfLife = 120000;  // 0.12 second.
 
-// The target deadline utilization signal. This is a trade-off between quality
+// The target encoder utilization signal. This is a trade-off between quality
 // and less CPU usage. The range of this value is [0, 1]. Higher the value,
 // better the quality and higher the CPU usage.
 //
 // For machines with more than two encoding threads.
-const double kHiTargetDeadlineUtilization = 0.7;
+const double kHiTargetEncoderUtilization = 0.7;
 // For machines with two encoding threads.
-const double kMidTargetDeadlineUtilization = 0.6;
+const double kMidTargetEncoderUtilization = 0.6;
 // For machines with single encoding thread.
-const double kLoTargetDeadlineUtilization = 0.5;
+const double kLoTargetEncoderUtilization = 0.5;
 
 // This is the equivalent change on encoding speed for the change on each
 // quantizer step.
 const double kEquivalentEncodingSpeedStepPerQpStep = 1 / 20.0;
 
 // Highest/lowest allowed encoding speed set to the encoder. The valid range
 // is [4, 16]. Experiments show that with speed higher than 12, the saving of
 // the encoding time is not worth the dropping of the quality. And with speed
 // lower than 6, the increasing of quality is not worth the increasing of
 // encoding time.
 const int kHighestEncodingSpeed = 12;
 const int kLowestEncodingSpeed = 6;
 
 bool HasSufficientFeedback(
     const FeedbackSignalAccumulator<base::TimeDelta>& accumulator) {
   const base::TimeDelta amount_of_history =
       accumulator.update_time() - accumulator.reset_time();
   return amount_of_history.InMicroseconds() >= 250000;  // 0.25 second.
 }
 
 }  // namespace
 
 Vp8Encoder::Vp8Encoder(const VideoSenderConfig& video_config)
     : cast_config_(video_config),
-      target_deadline_utilization_(
+      target_encoder_utilization_(
           video_config.number_of_encode_threads > 2
-              ? kHiTargetDeadlineUtilization
+              ? kHiTargetEncoderUtilization
               : (video_config.number_of_encode_threads > 1
-                     ? kMidTargetDeadlineUtilization
-                     : kLoTargetDeadlineUtilization)),
+                     ? kMidTargetEncoderUtilization
+                     : kLoTargetEncoderUtilization)),
       key_frame_requested_(true),
       bitrate_kbit_(cast_config_.start_bitrate / 1000),
       next_frame_id_(FrameId::first()),
       has_seen_zero_length_encoded_frame_(false),
       encoding_speed_acc_(
           base::TimeDelta::FromMicroseconds(kEncodingSpeedAccHalfLife)),
       encoding_speed_(kHighestEncodingSpeed) {
   config_.g_timebase.den = 0;  // Not initialized.
   DCHECK_LE(cast_config_.min_qp, cast_config_.max_cpu_saver_qp);
   DCHECK_LE(cast_config_.max_cpu_saver_qp, cast_config_.max_qp);
@@ skipping 101 matching lines @@
   CHECK_EQ(vpx_codec_control(&encoder_, VP8E_SET_CPUUSED, -encoding_speed_),
            VPX_CODEC_OK);
 }
 
 void Vp8Encoder::Encode(const scoped_refptr<media::VideoFrame>& video_frame,
                         const base::TimeTicks& reference_time,
                         SenderEncodedFrame* encoded_frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(encoded_frame);
 
-  // Note: This is used to compute the |deadline_utilization| and so it uses the
+  // Note: This is used to compute the |encoder_utilization| and so it uses the
   // real-world clock instead of the CastEnvironment clock, the latter of which
   // might be simulated.
   const base::TimeTicks start_time = base::TimeTicks::Now();
 
   // Initialize on-demand.  Later, if the video frame size has changed, update
   // the encoder configuration.
   const gfx::Size frame_size = video_frame->visible_rect().size();
   if (!is_initialized() || gfx::Size(config_.g_w, config_.g_h) != frame_size)
     ConfigureForNewFrameSize(frame_size);
 
@@ skipping 95 matching lines @@
         encoded_frame->frame_id.lower_32_bits(),
         encoded_frame->rtp_timestamp.lower_32_bits(),
         static_cast<int>(config_.rc_target_bitrate),
         key_frame_requested_ ? 'Y' : 'N');
     base::debug::SetCrashKeyValue(kZeroEncodeDetails, details);
     // Please forward crash reports to http://crbug.com/519022:
     base::debug::DumpWithoutCrashing();
     base::debug::ClearCrashKey(kZeroEncodeDetails);
   }
 
-  // Compute deadline utilization as the real-world time elapsed divided by the
+  // Compute encoder utilization as the real-world time elapsed divided by the
   // frame duration.
   const base::TimeDelta processing_time = base::TimeTicks::Now() - start_time;
-  encoded_frame->deadline_utilization =
+  encoded_frame->encoder_utilization =
       processing_time.InSecondsF() / predicted_frame_duration.InSecondsF();
 
   // Compute lossy utilization.  The VP8 encoder took an estimated guess at what
   // quantizer value would produce an encoded frame size as close to the target
   // as possible.  Now that the frame has been encoded and the number of bytes
   // is known, the perfect quantizer value (i.e., the one that should have been
   // used) can be determined.  This perfect quantizer is then normalized and
   // used as the lossy utilization.
   const double actual_bitrate =
       encoded_frame->data.size() * 8.0 / predicted_frame_duration.InSecondsF();
   const double target_bitrate = 1000.0 * config_.rc_target_bitrate;
   DCHECK_GT(target_bitrate, 0.0);
   const double bitrate_utilization = actual_bitrate / target_bitrate;
   int quantizer = -1;
   CHECK_EQ(vpx_codec_control(&encoder_, VP8E_GET_LAST_QUANTIZER_64, &quantizer),
            VPX_CODEC_OK);
   const double perfect_quantizer = bitrate_utilization * std::max(0, quantizer);
   // Side note: If it was possible for the encoder to encode within the target
   // number of bytes, the |perfect_quantizer| will be in the range [0.0,63.0].
   // If it was never possible, the value will be greater than 63.0.
   encoded_frame->lossy_utilization = perfect_quantizer / 63.0;
 
   DVLOG(2) << "VP8 encoded frame_id " << encoded_frame->frame_id
            << ", sized: " << encoded_frame->data.size()
-           << ", deadline_utilization: " << encoded_frame->deadline_utilization
+           << ", encoder_utilization: " << encoded_frame->encoder_utilization
            << ", lossy_utilization: " << encoded_frame->lossy_utilization
            << " (quantizer chosen by the encoder was " << quantizer << ')';
 
   if (encoded_frame->dependency == EncodedFrame::KEY) {
     key_frame_requested_ = false;
   }
   if (encoded_frame->dependency == EncodedFrame::KEY) {
     encoding_speed_acc_.Reset(kHighestEncodingSpeed, video_frame->timestamp());
   } else {
     // Equivalent encoding speed considering both cpu_used setting and
     // quantizer.
     double actual_encoding_speed =
         encoding_speed_ +
         kEquivalentEncodingSpeedStepPerQpStep *
             std::max(0, quantizer - cast_config_.min_qp);
     double adjusted_encoding_speed = actual_encoding_speed *
-                                     encoded_frame->deadline_utilization /
-                                     target_deadline_utilization_;
+                                     encoded_frame->encoder_utilization /
+                                     target_encoder_utilization_;
     encoding_speed_acc_.Update(adjusted_encoding_speed,
                                video_frame->timestamp());
   }
 
   if (HasSufficientFeedback(encoding_speed_acc_)) {
     // Predict |encoding_speed_| and |min_quantizer| for next frame.
     // When CPU is constrained, increase encoding speed and increase
     // |min_quantizer| if needed.
     double next_encoding_speed = encoding_speed_acc_.current();
     int next_min_qp;
@@ skipping 41 matching lines @@
   VLOG(1) << "VP8 new rc_target_bitrate: " << new_bitrate_kbit << " kbps";
 }
 
 void Vp8Encoder::GenerateKeyFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
   key_frame_requested_ = true;
 }
 
 }  // namespace cast
 }  // namespace media