pepper: add software vp9 encoder support to PPB_VideoEncoder

content/renderer/pepper/video_encoder_shim.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/pepper/video_encoder_shim.h"
 
 #include <inttypes.h>
 
 #include <deque>
 
@@ skipping 12 matching lines @@
 
 namespace content {
 
 // TODO(llandwerlin): Libvpx doesn't seem to have a maximum frame size
 // limitation. We currently limit the size of the frames to encode at
 // 1080p (%64 pixels blocks), this seems like a reasonable limit for
 // software encoding.
 const int32_t kMaxWidth = 1920;
 const int32_t kMaxHeight = 1088;
 
-// Default speed for the encoder (same as WebRTC). Increases the CPU
-// usage as the value is more negative (VP8 valid range: -16..16).
-const int32_t kDefaultCpuUsed = -6;
-
-// Default quantizer min/max values.
-const int32_t kDefaultMinQuantizer = 2;
-const int32_t kDefaultMaxQuantizer = 52;
-
 // Bitstream buffer size.
 const uint32_t kBitstreamBufferSize = 2 * 1024 * 1024;
 
 // Number of frames needs at any given time.
 const uint32_t kInputFrameCount = 1;
 
+// Magic encoder constants for VP9 adaptive quantization strategy.

[bbudge, 2015/08/05 17:04:41]

nit: s/constants/constant
Or do you want to move more magic numbers here? I think it's a good idea, so you
can add some commentary on why the particular values are chosen.

[llandwerlin-old, 2015/08/05 17:35:55]

Done.

+const int kVp9AqModeCyclicRefresh = 3;
+
+namespace {
+
+struct CodecDescription {

[bbudge, 2015/08/05 17:04:41]

This class just holds parameter values, and some state about whether the codec
is valid. I think you could eliminate this struct, define some kConstants for
the magic numbers, check for a valid codec value in
VideoEncoderShim::Initialize, and switch in EncoderImpl::Initialize on that.

[llandwerlin-old, 2015/08/05 17:35:55]

Replaced with a function that does the switch on return values.
A switch in EncoderImpl::Initialize doesn't feel pratical as there is a fair
amount of error checking there.

+  CodecDescription()
+      : codec(media::VIDEO_CODEC_PROFILE_UNKNOWN),
+        vpx_codec(nullptr),
+        cpu_used(0),
+        min_quantizer(0),
+        max_quantizer(0) {}
+  CodecDescription(media::VideoCodecProfile codec,
+                   vpx_codec_iface_t* vpx_codec,
+                   int32_t cpu_used,
+                   uint32_t min_quantizer,
+                   uint32_t max_quantizer)
+      : codec(codec),
+        vpx_codec(vpx_codec),
+        cpu_used(cpu_used),
+        min_quantizer(min_quantizer),
+        max_quantizer(max_quantizer) {}
+  ~CodecDescription() {}
+
+  bool IsValid() { return vpx_codec != nullptr; }
+
+  media::VideoCodecProfile codec;
+
+  // Libvpx codec interface.
+  vpx_codec_iface_t* vpx_codec;
+
+  // Default speed for the encoder. Increases the CPU usage as the
+  // value is more negative (VP8 valid range: -16..16, VP9 valid
+  // range: -8..8).
+  int32_t cpu_used;
+
+  // Default quantizer min/max values.
+  uint32_t min_quantizer;
+  uint32_t max_quantizer;
+};
+
+CodecDescription PP_ToVpxVideoCodecIface(media::VideoCodecProfile codec) {
+  switch (codec) {
+    case media::VP8PROFILE_ANY:
+      // Using same parameters as WebRTC (see media/cast/sender).
+      return CodecDescription(codec, vpx_codec_vp8_cx(), -6, 2, 52);
+    case media::VP9PROFILE_ANY:
+      return CodecDescription(codec, vpx_codec_vp9_cx(), 6, 20, 30);
+    default:
+      return CodecDescription();
+  }
+}
+
+}  // namespace
+
 class VideoEncoderShim::EncoderImpl {
  public:
   explicit EncoderImpl(const base::WeakPtr<VideoEncoderShim>& shim);
   ~EncoderImpl();
 
   void Initialize(media::VideoPixelFormat input_format,
                   const gfx::Size& input_visible_size,
-                  media::VideoCodecProfile output_profile,
+                  const CodecDescription& codec_descr,
                   uint32 initial_bitrate);
   void Encode(const scoped_refptr<media::VideoFrame>& frame,
               bool force_keyframe);
   void UseOutputBitstreamBuffer(const media::BitstreamBuffer& buffer,
                                 uint8_t* mem);
   void RequestEncodingParametersChange(uint32 bitrate, uint32 framerate);
   void Stop();
 
  private:
   struct PendingEncode {
@@ skipping 41 matching lines @@
 }
 
 VideoEncoderShim::EncoderImpl::~EncoderImpl() {
   if (initialized_)
     vpx_codec_destroy(&encoder_);
 }
 
 void VideoEncoderShim::EncoderImpl::Initialize(
     media::VideoPixelFormat input_format,
     const gfx::Size& input_visible_size,
-    media::VideoCodecProfile output_profile,
+    const CodecDescription& codec_descr,

[bbudge, 2015/08/05 17:04:41]

nit: desc is a more common abbreviation for description or descriptor in
chromium. Also to be consistent with codec_desc in Initialize.

[llandwerlin-old, 2015/08/05 17:35:55]

Done.

     uint32 initial_bitrate) {
   gfx::Size coded_size =
       media::VideoFrame::PlaneSize(input_format, 0, input_visible_size);
 
   // Populate encoder configuration with default values.
-  if (vpx_codec_enc_config_default(vpx_codec_vp8_cx(), &config_, 0) !=
+  if (vpx_codec_enc_config_default(codec_descr.vpx_codec, &config_, 0) !=
       VPX_CODEC_OK) {
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
 
-  config_.g_threads = 1;
   config_.g_w = input_visible_size.width();
   config_.g_h = input_visible_size.height();
 
   framerate_ = config_.g_timebase.den;
 
   config_.g_lag_in_frames = 0;
   config_.g_timebase.num = 1;
   config_.g_timebase.den = base::Time::kMicrosecondsPerSecond;
   config_.rc_target_bitrate = initial_bitrate / 1000;
-  config_.rc_min_quantizer = kDefaultMinQuantizer;
-  config_.rc_max_quantizer = kDefaultMaxQuantizer;
+  config_.rc_min_quantizer = codec_descr.min_quantizer;
+  config_.rc_max_quantizer = codec_descr.max_quantizer;
 
   vpx_codec_flags_t flags = 0;
-  if (vpx_codec_enc_init(&encoder_, vpx_codec_vp8_cx(), &config_, flags) !=
+  if (vpx_codec_enc_init(&encoder_, codec_descr.vpx_codec, &config_, flags) !=
       VPX_CODEC_OK) {
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
   initialized_ = true;
 
   if (vpx_codec_enc_config_set(&encoder_, &config_) != VPX_CODEC_OK) {
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
 
-  if (vpx_codec_control(&encoder_, VP8E_SET_CPUUSED, kDefaultCpuUsed) !=
+  if (vpx_codec_control(&encoder_, VP8E_SET_CPUUSED, codec_descr.cpu_used) !=
       VPX_CODEC_OK) {
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
 
+  if (codec_descr.codec == media::VP9PROFILE_ANY) {
+    if (vpx_codec_control(&encoder_, VP9E_SET_AQ_MODE,
+                          kVp9AqModeCyclicRefresh) != VPX_CODEC_OK) {
+      NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
+      return;
+    }
+  }
+
   renderer_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoEncoderShim::OnRequireBitstreamBuffers, shim_,
                  kInputFrameCount, coded_size, kBitstreamBufferSize));
 }
 
 void VideoEncoderShim::EncoderImpl::Encode(
     const scoped_refptr<media::VideoFrame>& frame,
     bool force_keyframe) {
   frames_.push_back(PendingEncode(frame, force_keyframe));
@@ skipping 135 matching lines @@
     media::VideoEncodeAccelerator::SupportedProfile profile;
     profile.profile = media::VP8PROFILE_ANY;
     profile.max_resolution = gfx::Size(kMaxWidth, kMaxHeight);
     // Libvpx and media::VideoEncodeAccelerator are using opposite
     // notions of denominator/numerator.
     profile.max_framerate_numerator = config.g_timebase.den;
     profile.max_framerate_denominator = config.g_timebase.num;
     profiles.push_back(profile);
   }
 
+  ret = vpx_codec_enc_config_default(vpx_codec_vp9_cx(), &config, 0);
+  if (ret == VPX_CODEC_OK) {
+    media::VideoEncodeAccelerator::SupportedProfile profile;
+    profile.profile = media::VP9PROFILE_ANY;
+    profile.max_resolution = gfx::Size(kMaxWidth, kMaxHeight);
+    profile.max_framerate_numerator = config.g_timebase.den;
+    profile.max_framerate_denominator = config.g_timebase.num;
+    profiles.push_back(profile);
+  }
+
   return profiles;
 }
 
 bool VideoEncoderShim::Initialize(
     media::VideoPixelFormat input_format,
     const gfx::Size& input_visible_size,
     media::VideoCodecProfile output_profile,
     uint32 initial_bitrate,
     media::VideoEncodeAccelerator::Client* client) {
   DCHECK(RenderThreadImpl::current());
   DCHECK_EQ(client, host_);
 
   if (input_format != media::PIXEL_FORMAT_I420)
     return false;
 
+  CodecDescription codec_desc = PP_ToVpxVideoCodecIface(output_profile);
+  if (!codec_desc.IsValid())
+    return false;
+
   media_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoEncoderShim::EncoderImpl::Initialize,
-                 base::Unretained(encoder_impl_.get()), input_format,
-                 input_visible_size, output_profile, initial_bitrate));
+      FROM_HERE, base::Bind(&VideoEncoderShim::EncoderImpl::Initialize,
+                            base::Unretained(encoder_impl_.get()), input_format,
+                            input_visible_size, codec_desc, initial_bitrate));
 
   return true;
 }
 
 void VideoEncoderShim::Encode(const scoped_refptr<media::VideoFrame>& frame,
                               bool force_keyframe) {
   DCHECK(RenderThreadImpl::current());
 
   media_task_runner_->PostTask(
       FROM_HERE,
@@ skipping 50 matching lines @@
 }
 
 void VideoEncoderShim::OnNotifyError(
     media::VideoEncodeAccelerator::Error error) {
   DCHECK(RenderThreadImpl::current());
 
   host_->NotifyError(error);
 }
 
 }  // namespace content