VideoTrackRecorder: limit VP9 cpu usage and quality

content/renderer/media/video_track_recorder.cc

 // Copyright 2015 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 "content/renderer/media/video_track_recorder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 242 matching lines @@
     // than-or-equal than the old size, in terms of area, the existing encoder
     // instance could be reused after changing |codec_config_.{g_w,g_h}|.
     DVLOG(1) << "Destroying/Re-Creating encoder for new frame size: "
              << gfx::Size(codec_config_.g_w, codec_config_.g_h).ToString()
              << " --> " << size.ToString() << (use_vp9_ ? " vp9" : " vp8");
     encoder_.reset();
   }
 
   const vpx_codec_iface_t* interface =
       use_vp9_ ? vpx_codec_vp9_cx() : vpx_codec_vp8_cx();
-  const vpx_codec_err_t result = vpx_codec_enc_config_default(interface,
-                                                              &codec_config_,
-                                                              0 /* reserved */);
+  vpx_codec_err_t result =
+      vpx_codec_enc_config_default(interface, &codec_config_, 0 /* reserved */);
   DCHECK_EQ(VPX_CODEC_OK, result);
 
   DCHECK_EQ(320u, codec_config_.g_w);
   DCHECK_EQ(240u, codec_config_.g_h);
   DCHECK_EQ(256u, codec_config_.rc_target_bitrate);
   // Use the selected bitrate or adjust default bit rate to account for the
   // actual size.
   if (bits_per_second_ > 0) {
     codec_config_.rc_target_bitrate = bits_per_second_;
   } else {
     codec_config_.rc_target_bitrate = size.GetArea() *
                                       codec_config_.rc_target_bitrate /
                                       codec_config_.g_w / codec_config_.g_h;
   }
   // Both VP8/VP9 configuration should be Variable BitRate by default.
   DCHECK_EQ(VPX_VBR, codec_config_.rc_end_usage);
   if (use_vp9_) {
     // Number of frames to consume before producing output.
     codec_config_.g_lag_in_frames = 0;
 
     // DCHECK that the profile selected by default is I420 (magic number 0).
     DCHECK_EQ(0u, codec_config_.g_profile);
+
+    // Request the lowest-CPU usage that VP9 supports. Values greater than 0
+    // will increase encoder speed at the expense of quality. Note that this is
+    // configured via the same parameter as for VP8.
+    const int kCpuUsage = 6;
+    result = vpx_codec_control(encoder_.get(), VP8E_SET_CPUUSED, kCpuUsage);

[miu, 2016/02/25 20:22:09]

6 is actually a high-end setting (4 being the highest, IIRC).  Most users
machines will not be able to encode in real-time at this setting.  If your goal
is to reduce CPU usage, you probably will want to set this to 12, but then
you'll take a quality hit.

(In media/cast code, we actually micro-manage this setting, instead of using the
codec's built-in logic, to make the trade-off for each frame.)

Also, I noticed you're not setting |codec_config_.gthreads|, so perhaps you're
not leveraging multi-threaded encode right now?  For media/cast, we set this to
ceil(num processor cores / 2).

[mcasas, 2016/02/26 01:34:32]

Let's go for a compromise of 10. Users can still use
the bitrate parameter.
It's done in l.327.

+    DLOG_IF(WARNING, VPX_CODEC_OK != result) << "Failed to set CPUUSED";
+
+    // Clamping the quantizer constrains the worst-case quality and CPU usage.
+    codec_config_.rc_min_quantizer = 20;

[miu, 2016/02/25 20:22:09]

When you clamp the quantizer values this way, the encoder can and will use
waaaay more bandwidth than your target bandwidth setting (could be 5X or more!).
 It's generally best to keep these at their defaults.

[mcasas, 2016/02/26 01:34:32]

Done.

+    codec_config_.rc_max_quantizer = 30;
   } else {
     // VP8 always produces frames instantaneously.
     DCHECK_EQ(0u, codec_config_.g_lag_in_frames);
   }
 
   DCHECK(size.width());
   DCHECK(size.height());
   codec_config_.g_w = size.width();
   codec_config_.g_h = size.height();
   codec_config_.g_pass = VPX_RC_ONE_PASS;
@@ skipping 96 matching lines @@
   encoder_->set_paused(false);
 }
 
 void VideoTrackRecorder::OnVideoFrameForTesting(
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks timestamp) {
   encoder_->StartFrameEncode(frame, timestamp);
 }
 
 }  // namespace content