video_encode_accelerator: add initial_framerate to initial Config

Currently on VideoEncodeAccelerator::Initialize() deafult framerate is
always used to initialize encoder. As we have profile and level of H.264
encoding in initial Config, framerate should be also adjustable on
initialization for the client to configure a supportable parameter set
under the limit of of profile/level.

BUG=871154
TEST=build and deploy chrome on eve
TEST=build and run video_encoder_accelerator_unittest on eve

Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel
Change-Id: Ifd6e33ada82d44c0e1b46f56856caeec9600e139
Reviewed-on: https://chromium-review.googlesource.com/1163592Reviewed-by: Dan Sanders <sandersd@chromium.org>
Reviewed-by: Pawel Osciak <posciak@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Commit-Queue: Pin-chih Lin <johnylin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#582510}

media/gpu/v4l2/v4l2_video_encode_accelerator.cc

@@ -250,7 +250,9 @@ bool V4L2VideoEncodeAccelerator::Initialize(const Config& config,
     return false;
   }
 
-  RequestEncodingParametersChange(config.initial_bitrate, kInitialFramerate);
+  RequestEncodingParametersChange(
+      config.initial_bitrate,
+      config.initial_framerate.value_or(kDefaultFramerate));
 
   encoder_state_ = kInitialized;
 

media/gpu/v4l2/v4l2_video_encode_accelerator.h

@@ -91,7 +91,7 @@ class MEDIA_GPU_EXPORT V4L2VideoEncodeAccelerator
   };
 
   enum {
-    kInitialFramerate = 30,
+    kDefaultFramerate = 30,
     // These are rather subjectively tuned.
     kInputBufferCount = 2,
     kOutputBufferCount = 2,

media/gpu/vaapi/vaapi_video_encode_accelerator.cc

@@ -296,8 +296,10 @@ void VaapiVideoEncodeAccelerator::InitializeTask(const Config& config) {
 
   // TODO(johnylin): pass |config.h264_output_level| to H264Encoder.
   //                 https://crbug.com/863327
-  if (!encoder_->Initialize(config.input_visible_size, config.output_profile,
-                            config.initial_bitrate, kDefaultFramerate)) {
+  if (!encoder_->Initialize(
+          config.input_visible_size, config.output_profile,
+          config.initial_bitrate,
+          config.initial_framerate.value_or(kDefaultFramerate))) {
     NOTIFY_ERROR(kInvalidArgumentError, "Failed initializing encoder");
     return;
   }

media/gpu/video_encode_accelerator_unittest.cc

@@ -1478,14 +1478,9 @@ VEAClient::VEAClient(TestStream* test_stream,
 
 // Helper function to create VEA.
 static std::unique_ptr<VideoEncodeAccelerator> CreateVideoEncodeAccelerator(
-    VideoPixelFormat input_format,
-    const gfx::Size& input_visible_size,
-    VideoCodecProfile output_profile,
-    uint32_t initial_bitrate,
+    const VideoEncodeAccelerator::Config& config,
     VideoEncodeAccelerator::Client* client,
     const gpu::GpuPreferences& gpu_preferences) {
-  const VideoEncodeAccelerator::Config config(input_format, input_visible_size,
-                                              output_profile, initial_bitrate);
   if (g_fake_encoder) {
     std::unique_ptr<VideoEncodeAccelerator> encoder(
         new FakeVideoEncodeAccelerator(
@@ -1508,9 +1503,10 @@ void VEAClient::CreateEncoder() {
   DVLOG(1) << "Profile: " << test_stream_->requested_profile
            << ", initial bitrate: " << requested_bitrate_;
 
-  encoder_ = CreateVideoEncodeAccelerator(
+  const VideoEncodeAccelerator::Config config(
       kInputFormat, test_stream_->visible_size, test_stream_->requested_profile,
-      requested_bitrate_, this, gpu::GpuPreferences());
+      requested_bitrate_, requested_framerate_);
+  encoder_ = CreateVideoEncodeAccelerator(config, this, gpu::GpuPreferences());
   if (!encoder_) {
     LOG(ERROR) << "Failed creating a VideoEncodeAccelerator.";
     SetState(CS_ERROR);
@@ -2128,9 +2124,10 @@ void SimpleVEAClientBase::CreateEncoder() {
   LOG_ASSERT(g_env->test_streams_.size());
 
   gfx::Size visible_size(width_, height_);
-  encoder_ = CreateVideoEncodeAccelerator(
+  const VideoEncodeAccelerator::Config config(
       kInputFormat, visible_size, g_env->test_streams_[0]->requested_profile,
-      bitrate_, this, gpu::GpuPreferences());
+      bitrate_, fps_);
+  encoder_ = CreateVideoEncodeAccelerator(config, this, gpu::GpuPreferences());
   if (!encoder_) {
     LOG(ERROR) << "Failed creating a VideoEncodeAccelerator.";
     SetState(CS_ERROR);

media/mojo/interfaces/video_encode_accelerator.mojom

@@ -49,6 +49,8 @@ struct VideoEncodeAcceleratorConfig {
   gfx.mojom.Size input_visible_size;
   VideoCodecProfile output_profile;
   uint32 initial_bitrate;
+  uint32 initial_framerate;
+  bool has_initial_framerate;  // Whether or not config has initial framerate
   uint8 h264_output_level;
   bool has_h264_output_level;  // Whether or not config has H264 output level
 };

media/mojo/interfaces/video_encode_accelerator_mojom_traits.cc

@@ -133,6 +133,11 @@ bool StructTraits<media::mojom::VideoEncodeAcceleratorConfigDataView,
   if (!input.ReadOutputProfile(&output_profile))
     return false;
 
+  base::Optional<uint32_t> initial_framerate;
+  if (input.has_initial_framerate()) {
+    initial_framerate = input.initial_framerate();
+  }
+
   base::Optional<uint8_t> h264_output_level;
   if (input.has_h264_output_level()) {
     h264_output_level = input.h264_output_level();
@@ -140,7 +145,7 @@ bool StructTraits<media::mojom::VideoEncodeAcceleratorConfigDataView,
 
   *output = media::VideoEncodeAccelerator::Config(
       input_format, input_visible_size, output_profile, input.initial_bitrate(),
-      h264_output_level);
+      initial_framerate, h264_output_level);
   return true;
 }
 

media/mojo/interfaces/video_encode_accelerator_mojom_traits.h

@@ -98,6 +98,16 @@ struct StructTraits<media::mojom::VideoEncodeAcceleratorConfigDataView,
     return input.initial_bitrate;
   }
 
+  static uint32_t initial_framerate(
+      const media::VideoEncodeAccelerator::Config& input) {
+    return input.initial_framerate.value_or(0);
+  }
+
+  static bool has_initial_framerate(
+      const media::VideoEncodeAccelerator::Config& input) {
+    return input.initial_framerate.has_value();
+  }
+
   static uint8_t h264_output_level(
       const media::VideoEncodeAccelerator::Config& input) {
     return input.h264_output_level.value_or(0);

media/video/video_encode_accelerator.cc

@@ -35,11 +35,13 @@ VideoEncodeAccelerator::Config::Config(
     const gfx::Size& input_visible_size,
     VideoCodecProfile output_profile,
     uint32_t initial_bitrate,
+    base::Optional<uint32_t> initial_framerate,
     base::Optional<uint8_t> h264_output_level)
     : input_format(input_format),
       input_visible_size(input_visible_size),
       output_profile(output_profile),
       initial_bitrate(initial_bitrate),
+      initial_framerate(initial_framerate),
       h264_output_level(h264_output_level) {}
 
 VideoEncodeAccelerator::Config::~Config() = default;
@@ -51,6 +53,10 @@ std::string VideoEncodeAccelerator::Config::AsHumanReadableString() const {
       VideoPixelFormatToString(input_format).c_str(),
       input_visible_size.ToString().c_str(),
       GetProfileName(output_profile).c_str(), initial_bitrate);
+  if (initial_framerate) {
+    str += base::StringPrintf(", initial_framerate: %u",
+                              initial_framerate.value());
+  }
   if (h264_output_level) {
     str += base::StringPrintf(", h264_output_level: %u",
                               h264_output_level.value());

media/video/video_encode_accelerator.h

@@ -102,6 +102,7 @@ class MEDIA_EXPORT VideoEncodeAccelerator {
            const gfx::Size& input_visible_size,
            VideoCodecProfile output_profile,
            uint32_t initial_bitrate,
+           base::Optional<uint32_t> initial_framerate = base::nullopt,
            base::Optional<uint8_t> h264_output_level = base::nullopt);
 
     ~Config();
@@ -122,6 +123,10 @@ class MEDIA_EXPORT VideoEncodeAccelerator {
     // Initial bitrate of encoded output stream in bits per second.
     uint32_t initial_bitrate;
 
+    // Initial encoding framerate in frames per second. This is optional and
+    // VideoEncodeAccelerator should use default framerate if not given.
+    base::Optional<uint32_t> initial_framerate;
+
     // Codec level of encoded output stream for H264 only. This value should
     // be aligned to the H264 standard definition of SPS.level_idc. The only
     // exception is in Main and Baseline profile we still use