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 while keeping a certain
+    // quality. Values greater than 0 will increase encoder speed at the expense
+    // of quality. Note: this is configured via the same parameter as for VP8.
+    const int kCpuUsage = 10;

[miu, 2016/02/26 19:27:49]

It's important you understand what this does: Internally, this is a parameter
(X) to the following formula:

  Target Encode CPU Time = Frame Duration * (16 - X) / 16

For example, if the frame is 33 ms in duration (30 FPS content) and you use a
CPU speed of 10, the encoder would TARGET spending 12.4 ms of CPU time to encode
the frame.  It would skip steps that improve quality and reduce bandwidth
utilization in order to avoid going over that target.

If CPU speed were 6, all other values the same, it would spend 20.6 ms (almost
double) to encode the frame.

So, the question is: What behavior do you really want here?  You'll want to
consider what you need to be leaving CPU available for (e.g., Chrome needs some
CPU for compositing, web rendering, and other things; plus we need to leave
slack for applications other than Chrome running on the system).  One possible
scheme:

  if (number_of_proc_cores == 1)
    vpx_codec_control(set cpu speed = 12);
  else if (number of proc cores <= 2)
    vpx_codec_control(set cpu speed = 10);
  else if (number_of_proc_cores <= 4)
    vpx_codec_control(set cpu speed = 8);
  else
    vpx_codec_control(set cpu speed = 6);

[mcasas, 2016/02/26 22:18:22]

Hmmm talking about implementation details
leaking... :)

Ok, the goal here is to move the dial away
from the 0, which basically means "take the
whole frame interval" to "leave a bit of slack
if there are few cores". If possible, without
degrading the quality significantly. Since we
are dealing with relatively static scenes 
(vid calls) we should achieve this results
easily, and I think the new set of numbers
would make sense. SGTY?

+    result = vpx_codec_control(encoder_.get(), VP8E_SET_CPUUSED, kCpuUsage);
+    DLOG_IF(WARNING, VPX_CODEC_OK != result) << "Failed to set CPUUSED";
   } 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