RELAND: Merge VideoSenderConfig and AudioSenderConfig.

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 45 matching lines @@
 
 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)
+Vp8Encoder::Vp8Encoder(const FrameSenderConfig& video_config)
     : cast_config_(video_config),
       target_encoder_utilization_(
-          video_config.number_of_encode_threads > 2
+          video_config.video_codec_params.number_of_encode_threads > 2
               ? kHiTargetEncoderUtilization
-              : (video_config.number_of_encode_threads > 1
+              : (video_config.video_codec_params.number_of_encode_threads > 1
                      ? 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);
+  DCHECK_LE(cast_config_.video_codec_params.min_qp,
+            cast_config_.video_codec_params.max_cpu_saver_qp);
+  DCHECK_LE(cast_config_.video_codec_params.max_cpu_saver_qp,
+            cast_config_.video_codec_params.max_qp);
 
   thread_checker_.DetachFromThread();
 }
 
 Vp8Encoder::~Vp8Encoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (is_initialized())
     vpx_codec_destroy(&encoder_);
 }
 
 void Vp8Encoder::Initialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!is_initialized());
   // The encoder will be created/configured when the first frame encode is
   // requested.
 }
 
 void Vp8Encoder::ConfigureForNewFrameSize(const gfx::Size& frame_size) {
   if (is_initialized()) {
     // Workaround for VP8 bug: If the new size is strictly less-than-or-equal to
     // the old size, in terms of area, the existing encoder instance can
     // continue.  Otherwise, completely tear-down and re-create a new encoder to
     // avoid a shutdown crash.
     if (frame_size.GetArea() <= gfx::Size(config_.g_w, config_.g_h).GetArea()) {
       DVLOG(1) << "Continuing to use existing encoder at smaller frame size: "
                << gfx::Size(config_.g_w, config_.g_h).ToString() << " --> "
                << frame_size.ToString();
       config_.g_w = frame_size.width();
       config_.g_h = frame_size.height();
-      config_.rc_min_quantizer = cast_config_.min_qp;
+      config_.rc_min_quantizer = cast_config_.video_codec_params.min_qp;
       if (vpx_codec_enc_config_set(&encoder_, &config_) == VPX_CODEC_OK)
         return;
       DVLOG(1) << "libvpx rejected the attempt to use a smaller frame size in "
                   "the current instance.";
     }
 
     DVLOG(1) << "Destroying/Re-Creating encoder for larger frame size: "
              << gfx::Size(config_.g_w, config_.g_h).ToString() << " --> "
              << frame_size.ToString();
     vpx_codec_destroy(&encoder_);
   } else {
     DVLOG(1) << "Creating encoder for the first frame; size: "
              << frame_size.ToString();
   }
 
   // Populate encoder configuration with default values.
   CHECK_EQ(vpx_codec_enc_config_default(vpx_codec_vp8_cx(), &config_, 0),
            VPX_CODEC_OK);
 
-  config_.g_threads = cast_config_.number_of_encode_threads;
+  config_.g_threads = cast_config_.video_codec_params.number_of_encode_threads;
   config_.g_w = frame_size.width();
   config_.g_h = frame_size.height();
   // Set the timebase to match that of base::TimeDelta.
   config_.g_timebase.num = 1;
   config_.g_timebase.den = base::Time::kMicrosecondsPerSecond;
 
   // |g_pass| and |g_lag_in_frames| must be "one pass" and zero, respectively,
   // in order for VP8 to support changing frame sizes during encoding:
   config_.g_pass = VPX_RC_ONE_PASS;
   config_.g_lag_in_frames = 0;  // Immediate data output for each frame.
 
   // Rate control settings.
   config_.rc_dropframe_thresh = 0;  // The encoder may not drop any frames.
   config_.rc_resize_allowed = 0;  // TODO(miu): Why not?  Investigate this.
   config_.rc_end_usage = VPX_CBR;
   config_.rc_target_bitrate = bitrate_kbit_;
-  config_.rc_min_quantizer = cast_config_.min_qp;
-  config_.rc_max_quantizer = cast_config_.max_qp;
+  config_.rc_min_quantizer = cast_config_.video_codec_params.min_qp;
+  config_.rc_max_quantizer = cast_config_.video_codec_params.max_qp;
   // TODO(miu): Revisit these now that the encoder is being successfully
   // micro-managed.
   config_.rc_undershoot_pct = 100;
   config_.rc_overshoot_pct = 15;
   // TODO(miu): Document why these rc_buf_*_sz values were chosen and/or
   // research for better values.  Should they be computed from the target
   // playout delay?
   config_.rc_buf_initial_sz = 500;
   config_.rc_buf_optimal_sz = 600;
   config_.rc_buf_sz = 1000;
@@ skipping 182 matching lines @@
     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);
+            std::max(0, quantizer - cast_config_.video_codec_params.min_qp);
     double adjusted_encoding_speed = actual_encoding_speed *
                                      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;
     if (next_encoding_speed > kHighestEncodingSpeed) {
       double remainder = next_encoding_speed - kHighestEncodingSpeed;
       next_encoding_speed = kHighestEncodingSpeed;
       next_min_qp =
           static_cast<int>(remainder / kEquivalentEncodingSpeedStepPerQpStep +
-                           cast_config_.min_qp + 0.5);
-      next_min_qp = std::min(next_min_qp, cast_config_.max_cpu_saver_qp);
+                           cast_config_.video_codec_params.min_qp + 0.5);
+      next_min_qp = std::min(next_min_qp,
+                             cast_config_.video_codec_params.max_cpu_saver_qp);
     } else {
       next_encoding_speed =
           std::max<double>(kLowestEncodingSpeed, next_encoding_speed) + 0.5;
-      next_min_qp = cast_config_.min_qp;
+      next_min_qp = cast_config_.video_codec_params.min_qp;
     }
     if (encoding_speed_ != static_cast<int>(next_encoding_speed)) {
       encoding_speed_ = static_cast<int>(next_encoding_speed);
       CHECK_EQ(vpx_codec_control(&encoder_, VP8E_SET_CPUUSED, -encoding_speed_),
                VPX_CODEC_OK);
     }
     if (config_.rc_min_quantizer != static_cast<unsigned int>(next_min_qp)) {
       config_.rc_min_quantizer = static_cast<unsigned int>(next_min_qp);
       CHECK_EQ(vpx_codec_enc_config_set(&encoder_, &config_), VPX_CODEC_OK);
     }
@@ skipping 20 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