components/arc: use Config struct for Initialize of ArcVEA Mojo IPC

VideoEncodeAccelerator::Initialize() now use Config struct to pass
initial parameters. Change ArcVEA Mojo IPC to align with this new API.

BUG=867799
TEST=build and deploy chrome on Eve, verify ARC++ encoder is good

Change-Id: I0a4b1f80d2d5c6b8baa0fa734129ef1cc79b55ab
Reviewed-on: https://chromium-review.googlesource.com/1172463Reviewed-by: Pawel Osciak <posciak@chromium.org>
Reviewed-by: Greg Kerr <kerrnel@chromium.org>
Commit-Queue: Pin-chih Lin <johnylin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#587097}

components/arc/common/video_encode_accelerator.mojom

@@ -24,9 +24,31 @@ struct VideoEncodeProfile {
   uint32 max_framerate_denominator;
 };
 
+// The encoder parameter set which matches to
+// media::VideoEncodeAccelerator::Config.
+//  |input_format| is the pixel format of the input frames.
+//  |input_visible_size| is the resolution of the input frames.
+//  |output_profile| is the codec profile of the encoded output stream.
+//  |initial_bitrate| is the initial bitrate of the encoded output stream,
+//  in bits per second.
+//  |initial_framerate| is the initial requested framerate. It is optional, only
+//  valid when |has_initial_framerate| is true.
+//  |h264_output_level| is H264 level of encoded output stream. It is optional,
+//  only valid when |has_h264_output_level| is true.
+struct VideoEncodeAcceleratorConfig {
+  VideoPixelFormat input_format;
+  Size input_visible_size;
+  VideoCodecProfile output_profile;
+  uint32 initial_bitrate;
+  uint32 initial_framerate;
+  bool has_initial_framerate;
+  uint8 h264_output_level;
+  bool has_h264_output_level;
+};
+
 // Video encoder IPC interface.
 // Next MinVersion: 1
-// Next Method ID: 6
+// Next Method ID: 7
 interface VideoEncodeAccelerator {
 
   // The input buffer storage type.
@@ -69,11 +91,25 @@ interface VideoEncodeAccelerator {
   // Callback:
   //  Called with true iff initialization is successful. The client should not
   //  invoke any other methods before the callback.
-  Initialize@1(VideoPixelFormat input_format,
-               Size visible_size,
+  InitializeDeprecated@1(VideoPixelFormat input_format,
+                         Size visible_size,
+                         StorageType input_storage,
+                         VideoCodecProfile output_profile,
+                         uint32 initial_bitrate,
+                         VideoEncodeClient client) => (bool success);
+
+  // Initializes the video encoder with specific configuration.  Called once per
+  // encoder construction.
+  // Parameters:
+  //  |config| is the parameter set for encoder initialization.
+  //  |input_storage| the type of the input buffer.
+  //  |client| is the client of this video encoder. The client must be valid
+  //  during the lifetime of this accelerator.
+  // Callback:
+  //  Called with true iff initialization is successful. The client should not
+  //  invoke any other methods before the callback.
+  Initialize@6(VideoEncodeAcceleratorConfig config,
                StorageType input_storage,
-               VideoCodecProfile output_profile,
-               uint32 initial_bitrate,
                VideoEncodeClient client) => (bool success);
 
   // Encodes the given frame.

components/arc/common/video_encode_accelerator.typemap

@@ -5,6 +5,7 @@
 mojom = "//components/arc/common/video_encode_accelerator.mojom"
 public_headers = [ "//media/video/video_encode_accelerator.h" ]
 public_deps = [
+  "//base",
   "//media/gpu",
 ]
 traits_headers =
@@ -12,8 +13,12 @@ traits_headers =
 sources = [
   "//components/arc/common/video_encode_accelerator_struct_traits.cc",
 ]
+deps = [
+  "//base",
+]
 type_mappings = [
   "arc.mojom.VideoEncodeAccelerator.Error=media::VideoEncodeAccelerator::Error",
   "arc.mojom.VideoPixelFormat=media::VideoPixelFormat",
   "arc.mojom.VideoEncodeProfile=media::VideoEncodeAccelerator::SupportedProfile",
+  "arc.mojom.VideoEncodeAcceleratorConfig=media::VideoEncodeAccelerator::Config",
 ]

components/arc/common/video_encode_accelerator_struct_traits.cc

@@ -4,6 +4,9 @@
 
 #include "components/arc/common/video_encode_accelerator_struct_traits.h"
 
+#include "base/optional.h"
+#include "components/arc/common/video_accelerator_struct_traits.h"
+
 namespace mojo {
 
 // Make sure values in arc::mojom::VideoEncodeAccelerator::Error and
@@ -71,4 +74,37 @@ bool EnumTraits<arc::mojom::VideoPixelFormat, media::VideoPixelFormat>::
   }
 }
 
+// static
+bool StructTraits<arc::mojom::VideoEncodeAcceleratorConfigDataView,
+                  media::VideoEncodeAccelerator::Config>::
+    Read(arc::mojom::VideoEncodeAcceleratorConfigDataView input,
+         media::VideoEncodeAccelerator::Config* output) {
+  media::VideoPixelFormat input_format;
+  if (!input.ReadInputFormat(&input_format))
+    return false;
+
+  gfx::Size input_visible_size;
+  if (!input.ReadInputVisibleSize(&input_visible_size))
+    return false;
+
+  media::VideoCodecProfile output_profile;
+  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();
+  }
+
+  *output = media::VideoEncodeAccelerator::Config(
+      input_format, input_visible_size, output_profile, input.initial_bitrate(),
+      initial_framerate, h264_output_level);
+  return true;
+}
+
 }  // namespace mojo

components/arc/common/video_encode_accelerator_struct_traits.h

@@ -55,6 +55,53 @@ struct StructTraits<arc::mojom::VideoEncodeProfileDataView,
   }
 };
 
+template <>
+struct StructTraits<arc::mojom::VideoEncodeAcceleratorConfigDataView,
+                    media::VideoEncodeAccelerator::Config> {
+  static media::VideoPixelFormat input_format(
+      const media::VideoEncodeAccelerator::Config& input) {
+    return input.input_format;
+  }
+
+  static const gfx::Size& input_visible_size(
+      const media::VideoEncodeAccelerator::Config& input) {
+    return input.input_visible_size;
+  }
+
+  static media::VideoCodecProfile output_profile(
+      const media::VideoEncodeAccelerator::Config& input) {
+    return input.output_profile;
+  }
+
+  static uint32_t initial_bitrate(
+      const media::VideoEncodeAccelerator::Config& input) {
+    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);
+  }
+
+  static bool has_h264_output_level(
+      const media::VideoEncodeAccelerator::Config& input) {
+    return input.h264_output_level.has_value();
+  }
+
+  static bool Read(arc::mojom::VideoEncodeAcceleratorConfigDataView input,
+                   media::VideoEncodeAccelerator::Config* output);
+};
+
 }  // namespace mojo
 
 #endif  // COMPONENTS_ARC_COMMON_VIDEO_ENCODE_ACCELERATOR_STRUCT_TRAITS_H_

components/arc/video_accelerator/gpu_arc_video_encode_accelerator.cc

@@ -80,7 +80,7 @@ void GpuArcVideoEncodeAccelerator::GetSupportedProfiles(
           gpu_preferences_));
 }
 
-void GpuArcVideoEncodeAccelerator::Initialize(
+void GpuArcVideoEncodeAccelerator::InitializeDeprecated(
     VideoPixelFormat input_format,
     const gfx::Size& visible_size,
     VideoEncodeAccelerator::StorageType input_storage,
@@ -106,6 +106,26 @@ void GpuArcVideoEncodeAccelerator::Initialize(
   std::move(callback).Run(true);
 }
 
+void GpuArcVideoEncodeAccelerator::Initialize(
+    const media::VideoEncodeAccelerator::Config& config,
+    VideoEncodeAccelerator::StorageType input_storage,
+    VideoEncodeClientPtr client,
+    InitializeCallback callback) {
+  DVLOGF(2) << config.AsHumanReadableString();
+
+  input_pixel_format_ = config.input_format;
+  visible_size_ = config.input_visible_size;
+  accelerator_ = media::GpuVideoEncodeAcceleratorFactory::CreateVEA(
+      config, this, gpu_preferences_);
+  if (accelerator_ == nullptr) {
+    DLOG(ERROR) << "Failed to create a VideoEncodeAccelerator.";
+    std::move(callback).Run(false);
+    return;
+  }
+  client_ = std::move(client);
+  std::move(callback).Run(true);
+}
+
 static void DropShareMemoryAndVideoFrameDoneNotifier(
     std::unique_ptr<base::SharedMemory> shm,
     std::unique_ptr<VideoFrameDoneNotifier> notifier) {

components/arc/video_accelerator/gpu_arc_video_encode_accelerator.h

@@ -45,11 +45,15 @@ class GpuArcVideoEncodeAccelerator
 
   // ::arc::mojom::VideoEncodeAccelerator implementation.
   void GetSupportedProfiles(GetSupportedProfilesCallback callback) override;
-  void Initialize(VideoPixelFormat input_format,
-                  const gfx::Size& visible_size,
+  void InitializeDeprecated(VideoPixelFormat input_format,
+                            const gfx::Size& visible_size,
+                            VideoEncodeAccelerator::StorageType input_storage,
+                            VideoCodecProfile output_profile,
+                            uint32_t initial_bitrate,
+                            VideoEncodeClientPtr client,
+                            InitializeCallback callback) override;
+  void Initialize(const media::VideoEncodeAccelerator::Config& config,
                   VideoEncodeAccelerator::StorageType input_storage,
-                  VideoCodecProfile output_profile,
-                  uint32_t initial_bitrate,
                   VideoEncodeClientPtr client,
                   InitializeCallback callback) override;
   void Encode(mojo::ScopedHandle fd,