MediaRecorder: Tune complexity settings for VP9 encoding

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 {
@@ skipping 42 matching lines @@
       std::min(8, (base::SysInfo::NumberOfProcessors() + 1) / 2);
 
   // Number of frames to consume before producing output.
   codec_config_.g_lag_in_frames = 0;
 
   DCHECK(!encoder_);
   encoder_.reset(new vpx_codec_ctx_t);
   const vpx_codec_err_t ret = vpx_codec_enc_init(encoder_.get(), interface,
                                                  &codec_config_, kNoFlags);
   DCHECK_EQ(VPX_CODEC_OK, ret);
+
+  if (use_vp9_) {
+    // Values of VP8E_SET_CPUUSED greater than 0 will increase encoder speed at
+    // the expense of quality up to a maximum value of 8 for VP9, by tuning the
+    // target time spent encoding the frame. Go from 8 to 5 (values for real
+    // time encoding) depending on the amount of cores available in the system.
+    const int kCpuUsed =
+        std::max(5, 8 - base::SysInfo::NumberOfProcessors() / 2);
+    result = vpx_codec_control(encoder_.get(), VP8E_SET_CPUUSED, kCpuUsed);
+    DLOG_IF(WARNING, VPX_CODEC_OK != result) << "VP8E_SET_CPUUSED failed";
+  }
 }
 
 bool VideoTrackRecorder::VpxEncoder::IsInitialized() const {
   DCHECK(encoding_thread_->task_runner()->BelongsToCurrentThread());
   return codec_config_.g_timebase.den != 0;
 }
 
 base::TimeDelta VideoTrackRecorder::VpxEncoder::CalculateFrameDuration(
     const scoped_refptr<VideoFrame>& frame) {
   DCHECK(encoding_thread_->task_runner()->BelongsToCurrentThread());
@@ skipping 56 matching lines @@
   encoder_->set_paused(false);
 }
 
 void VideoTrackRecorder::OnVideoFrameForTesting(
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks timestamp) {
   encoder_->StartFrameEncode(frame, timestamp);
 }
 
 }  // namespace content