Add 4 VP9 profiles to the media::VideoCodecProfile enum.

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 56 matching lines @@
                            int32_t* min_quantizer,
                            int32_t* max_quantizer,
                            int32_t* cpu_used) {
   switch (codec) {
     case media::VP8PROFILE_ANY:
       *vpx_codec = vpx_codec_vp8_cx();
       *min_quantizer = kVp8DefaultMinQuantizer;
       *max_quantizer = kVp8DefaultMaxQuantizer;
       *cpu_used = kVp8DefaultCpuUsed;
       break;
-    case media::VP9PROFILE_ANY:
+    case media::VP9PROFILE_PROFILE0:
+    case media::VP9PROFILE_PROFILE1:
+    case media::VP9PROFILE_PROFILE2:
+    case media::VP9PROFILE_PROFILE3:
+      // TODO(servolk): These numbers should be adjusted for different profiles.
       *vpx_codec = vpx_codec_vp9_cx();
       *min_quantizer = kVp9DefaultMinQuantizer;
       *max_quantizer = kVp9DefaultMaxQuantizer;
       *cpu_used = kVp9DefaultCpuUsed;
       break;
     default:
       *vpx_codec = nullptr;
       *min_quantizer = 0;
       *max_quantizer = 0;
       *cpu_used = 0;
@@ skipping 101 matching lines @@
   config_.rc_max_quantizer = max_quantizer;
   // Do not saturate CPU utilization just for encoding. On a lower-end system
   // with only 1 or 2 cores, use only one thread for encoding. On systems with
   // more cores, allow half of the cores to be used for encoding.
   config_.g_threads =
       std::min(kMaxNumThreads, (base::SysInfo::NumberOfProcessors() + 1) / 2);
 
   // Use Q/CQ mode if no target bitrate is given. Note that in the VP8/CQ case
   // the meaning of rc_target_bitrate changes to target maximum rate.
   if (initial_bitrate == 0) {
-    if (output_profile == media::VP9PROFILE_ANY) {
+    if (output_profile == media::VP9PROFILE_PROFILE0 ||
+        output_profile == media::VP9PROFILE_PROFILE1 ||
+        output_profile == media::VP9PROFILE_PROFILE2 ||
+        output_profile == media::VP9PROFILE_PROFILE3) {
       config_.rc_end_usage = VPX_Q;
     } else if (output_profile == media::VP8PROFILE_ANY) {
       config_.rc_end_usage = VPX_CQ;
       config_.rc_target_bitrate = kVp8MaxCQBitrate;
     }
   }
 
   vpx_codec_flags_t flags = 0;
   if (vpx_codec_enc_init(&encoder_, 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, cpu_used) !=
       VPX_CODEC_OK) {
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
 
-  if (output_profile == media::VP9PROFILE_ANY) {
+  if (output_profile == media::VP9PROFILE_PROFILE0 ||
+      output_profile == media::VP9PROFILE_PROFILE1 ||
+      output_profile == media::VP9PROFILE_PROFILE2 ||
+      output_profile == media::VP9PROFILE_PROFILE3) {
     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_,
@@ skipping 145 matching lines @@
     // 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;
+    profile.profile = media::VP9PROFILE_PROFILE0;
+    profiles.push_back(profile);
+    profile.profile = media::VP9PROFILE_PROFILE1;
+    profiles.push_back(profile);
+    profile.profile = media::VP9PROFILE_PROFILE2;
+    profiles.push_back(profile);
+    profile.profile = media::VP9PROFILE_PROFILE3;
     profiles.push_back(profile);
   }
 
   return profiles;
 }
 
 bool VideoEncoderShim::Initialize(
     media::VideoPixelFormat input_format,
     const gfx::Size& input_visible_size,
     media::VideoCodecProfile output_profile,
     uint32_t initial_bitrate,
     media::VideoEncodeAccelerator::Client* client) {
   DCHECK(RenderThreadImpl::current());
   DCHECK_EQ(client, host_);
 
   if (input_format != media::PIXEL_FORMAT_I420)
     return false;
 
   if (output_profile != media::VP8PROFILE_ANY &&
-      output_profile != media::VP9PROFILE_ANY)
+      output_profile != media::VP9PROFILE_PROFILE0 &&
+      output_profile != media::VP9PROFILE_PROFILE1 &&
+      output_profile != media::VP9PROFILE_PROFILE2 &&
+      output_profile != media::VP9PROFILE_PROFILE3)
     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));
 
   return true;
 }
@@ skipping 57 matching lines @@
 }
 
 void VideoEncoderShim::OnNotifyError(
     media::VideoEncodeAccelerator::Error error) {
   DCHECK(RenderThreadImpl::current());
 
   host_->NotifyError(error);
 }
 
 }  // namespace content