media/mojo: Enable to pass VideoEncoderInfo via mojo

crrev.com/c/1949841 introduces VideoEncoderInfo. The info may be
useful for libwebrtc. The goal is to acquire VideoEncoderInfo of
hw encoders running in GPU process.
This CL is the second step, which enables to pass VideoEncoderInfo
via mojo.

Bug: 1031965
Test: webrtc.DecoderPerf.h264_hw
Test: webrtc.PeerConnection*
Change-Id: I55e985a92637f16e888c88e1682d5ec7178101f4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1973440Reviewed-by: Dominick Ng <dominickn@chromium.org>
Reviewed-by: Dan Sanders <sandersd@chromium.org>
Commit-Queue: Hirokazu Honda <hiroh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#726650}

media/mojo/clients/mojo_video_encode_accelerator.cc

@@ -12,6 +12,7 @@
 #include "media/base/video_frame.h"
 #include "media/gpu/gpu_video_accelerator_util.h"
 #include "media/mojo/common/mojo_shared_buffer_video_frame.h"
+#include "media/mojo/mojom/video_encoder_info.mojom.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/system/platform_handle.h"
@@ -39,6 +40,7 @@ class VideoEncodeAcceleratorClient
       int32_t bitstream_buffer_id,
       const media::BitstreamBufferMetadata& metadata) override;
   void NotifyError(VideoEncodeAccelerator::Error error) override;
+  void NotifyEncoderInfoChange(const VideoEncoderInfo& info) override;
 
  private:
   VideoEncodeAccelerator::Client* client_;
@@ -80,6 +82,12 @@ void VideoEncodeAcceleratorClient::NotifyError(
   client_->NotifyError(error);
 }
 
+void VideoEncodeAcceleratorClient::NotifyEncoderInfoChange(
+    const VideoEncoderInfo& info) {
+  DVLOG(2) << __func__;
+  client_->NotifyEncoderInfoChange(info);
+}
+
 }  // anonymous namespace
 
 MojoVideoEncodeAccelerator::MojoVideoEncodeAccelerator(

media/mojo/clients/mojo_video_encode_accelerator_unittest.cc

@@ -113,6 +113,7 @@ class MockVideoEncodeAcceleratorClient : public VideoEncodeAccelerator::Client {
   MOCK_METHOD2(BitstreamBufferReady,
                void(int32_t, const media::BitstreamBufferMetadata&));
   MOCK_METHOD1(NotifyError, void(VideoEncodeAccelerator::Error));
+  MOCK_METHOD1(NotifyEncoderInfoChange, void(const media::VideoEncoderInfo&));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockVideoEncodeAcceleratorClient);

media/mojo/mojom/BUILD.gn

@@ -38,6 +38,7 @@ mojom("mojom") {
     "video_decode_stats_recorder.mojom",
     "video_decoder.mojom",
     "video_encode_accelerator.mojom",
+    "video_encoder_info.mojom",
     "watch_time_recorder.mojom",
   ]
 
@@ -126,6 +127,7 @@ source_set("unit_tests") {
     "audio_decoder_config_mojom_traits_unittest.cc",
     "cdm_key_information_mojom_traits_unittest.cc",
     "video_decoder_config_mojom_traits_unittest.cc",
+    "video_encoder_info_mojom_traits_unittest.cc",
     "video_frame_mojom_traits_unittest.cc",
   ]
 
@@ -134,6 +136,7 @@ source_set("unit_tests") {
     "//base/test:test_support",
     "//media:test_support",
     "//media/mojo:test_support",
+    "//mojo/public/cpp/test_support:test_utils",
     "//testing/gmock",
     "//testing/gtest",
     "//ui/gfx:test_support",

media/mojo/mojom/typemaps.gni

@@ -20,6 +20,7 @@ typemaps = [
   "//media/mojo/mojom/video_decoder.typemap",
   "//media/mojo/mojom/video_decoder_config.typemap",
   "//media/mojo/mojom/video_encode_accelerator.typemap",
+  "//media/mojo/mojom/video_encoder_info.typemap",
   "//media/mojo/mojom/video_frame.typemap",
 ]
 

media/mojo/mojom/video_encode_accelerator.mojom

@@ -7,6 +7,7 @@ module media.mojom;
 import "media/mojo/mojom/media_types.mojom";
 import "mojo/public/mojom/base/time.mojom";
 import "ui/gfx/geometry/mojom/geometry.mojom";
+import "media/mojo/mojom/video_encoder_info.mojom";
 
 // This file is the Mojo version of the media::VideoEncodeAccelerator interface
 // and describes the communication between a Client and a remote "service"
@@ -83,7 +84,6 @@ interface VideoEncodeAccelerator {
   };
 
   // Responded by VideoEncodeAcceleratorClient.RequireBitstreamBuffers().
-  // TODO(mcasas): Update to asynchronous, https://crbug.com/744210.
   [Sync]
   Initialize(VideoEncodeAcceleratorConfig config,
              pending_remote<VideoEncodeAcceleratorClient> client)
@@ -123,4 +123,8 @@ interface VideoEncodeAcceleratorClient {
                        BitstreamBufferMetadata metadata);
 
   NotifyError(VideoEncodeAccelerator.Error error);
+
+  // VideoEncodeAccelerator calls this when its VideoEncoderInfo is changed.
+  // |info| is the updated VideoEncoderInfo.
+  NotifyEncoderInfoChange(VideoEncoderInfo info);
 };

media/mojo/mojom/video_encoder_info.mojom

+// Copyright 2017 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.
+
+module media.mojom;
+
+import "ui/gfx/geometry/mojom/geometry.mojom";
+
+struct ScalingSettings {
+  uint8 min_qp;
+  uint8 max_qp;
+};
+
+struct ResolutionBitrateLimit {
+  gfx.mojom.Size frame_size;
+  int32 min_start_bitrate_bps;
+  int32 min_bitrate_bps;
+  int32 max_bitrate_bps;
+};
+
+struct VideoEncoderInfo {
+  string implementation_name;
+
+  bool supports_native_handle;
+  bool has_trusted_rate_controller;
+  bool is_hardware_accelerated;
+  bool supports_simulcast;
+
+  ScalingSettings scaling_settings;
+  // This array size is equal to media::VideoEncoderInfo::kMaxSpatialLayers.
+  array<array<uint8>, 5> fps_allocation;
+  array<ResolutionBitrateLimit> resolution_bitrate_limits;
+};

media/mojo/mojom/video_encoder_info.typemap

+# Copyright 2019 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.
+
+mojom = "//media/mojo/mojom/video_encoder_info.mojom"
+
+public_headers = [ "//media/video/video_encoder_info.h" ]
+
+traits_headers = [ "//media/mojo/mojom/video_encoder_info_mojom_traits.h" ]
+
+sources = [
+  "//media/mojo/mojom/video_encoder_info_mojom_traits.cc",
+  "//media/mojo/mojom/video_encoder_info_mojom_traits.h",
+]
+
+public_deps = [
+  "//base",
+  "//media",
+]
+
+deps = [
+  "//media/base/ipc",
+  "//ui/gfx/geometry/mojom:mojom_traits",
+]
+
+type_mappings = [
+  "media.mojom.ScalingSettings=::media::ScalingSettings",
+  "media.mojom.ResolutionBitrateLimit=::media::ResolutionBitrateLimit",
+  "media.mojom.VideoEncoderInfo=::media::VideoEncoderInfo",
+]

media/mojo/mojom/video_encoder_info_mojom_traits.cc

+// Copyright 2019 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 "media/mojo/mojom/video_encoder_info_mojom_traits.h"
+
+namespace mojo {
+
+// static
+bool StructTraits<
+    media::mojom::ScalingSettingsDataView,
+    media::ScalingSettings>::Read(media::mojom::ScalingSettingsDataView data,
+                                  media::ScalingSettings* out) {
+  out->min_qp = data.min_qp();
+  out->max_qp = data.max_qp();
+  return true;
+}
+
+// static
+bool StructTraits<media::mojom::ResolutionBitrateLimitDataView,
+                  media::ResolutionBitrateLimit>::
+    Read(media::mojom::ResolutionBitrateLimitDataView data,
+         media::ResolutionBitrateLimit* out) {
+  if (!data.ReadFrameSize(&out->frame_size))
+    return false;
+  out->min_start_bitrate_bps = data.min_start_bitrate_bps();
+  out->min_bitrate_bps = data.min_bitrate_bps();
+  out->max_bitrate_bps = data.max_bitrate_bps();
+  return true;
+}
+
+// static
+bool StructTraits<
+    media::mojom::VideoEncoderInfoDataView,
+    media::VideoEncoderInfo>::Read(media::mojom::VideoEncoderInfoDataView data,
+                                   media::VideoEncoderInfo* out) {
+  out->supports_native_handle = data.supports_native_handle();
+  out->has_trusted_rate_controller = data.has_trusted_rate_controller();
+  out->is_hardware_accelerated = data.is_hardware_accelerated();
+  out->supports_simulcast = data.supports_simulcast();
+
+  if (!data.ReadImplementationName(&out->implementation_name))
+    return false;
+
+  if (!data.ReadScalingSettings(&out->scaling_settings))
+    return false;
+
+  base::span<std::vector<uint8_t>> fps_allocation(out->fps_allocation);
+  if (!data.ReadFpsAllocation(&fps_allocation))
+    return false;
+
+  if (!data.ReadResolutionBitrateLimits(&out->resolution_bitrate_limits))
+    return false;
+
+  return true;
+}
+}  // namespace mojo

media/mojo/mojom/video_encoder_info_mojom_traits.h

+// Copyright 2019 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.
+
+#ifndef MEDIA_MOJO_MOJOM_VIDEO_ENCODER_INFO_MOJOM_TRAITS_H_
+#define MEDIA_MOJO_MOJOM_VIDEO_ENCODER_INFO_MOJOM_TRAITS_H_
+
+#include "base/containers/span.h"
+#include "media/mojo/mojom/video_encoder_info.mojom.h"
+#include "media/video/video_encoder_info.h"
+#include "ui/gfx/geometry/mojom/geometry_mojom_traits.h"
+
+namespace mojo {
+
+template <>
+class StructTraits<media::mojom::ScalingSettingsDataView,
+                   media::ScalingSettings> {
+ public:
+  static int32_t min_qp(const media::ScalingSettings& scaling_settings) {
+    return scaling_settings.min_qp;
+  }
+  static int32_t max_qp(const media::ScalingSettings& scaling_settings) {
+    return scaling_settings.max_qp;
+  }
+
+  static bool Read(media::mojom::ScalingSettingsDataView data,
+                   media::ScalingSettings* out);
+};
+
+template <>
+class StructTraits<media::mojom::ResolutionBitrateLimitDataView,
+                   media::ResolutionBitrateLimit> {
+ public:
+  static const gfx::Size& frame_size(
+      const media::ResolutionBitrateLimit& resolution_bitrate_limit) {
+    return resolution_bitrate_limit.frame_size;
+  }
+  static int min_start_bitrate_bps(
+      const media::ResolutionBitrateLimit& resolution_bitrate_limit) {
+    return resolution_bitrate_limit.min_start_bitrate_bps;
+  }
+  static int min_bitrate_bps(
+      const media::ResolutionBitrateLimit& resolution_bitrate_limit) {
+    return resolution_bitrate_limit.min_bitrate_bps;
+  }
+  static int max_bitrate_bps(
+      const media::ResolutionBitrateLimit& resolution_bitrate_limit) {
+    return resolution_bitrate_limit.max_bitrate_bps;
+  }
+  static bool Read(media::mojom::ResolutionBitrateLimitDataView data,
+                   media::ResolutionBitrateLimit* out);
+};
+
+template <>
+class StructTraits<media::mojom::VideoEncoderInfoDataView,
+                   media::VideoEncoderInfo> {
+ public:
+  static const std::string& implementation_name(
+      const media::VideoEncoderInfo& video_encoder_info) {
+    return video_encoder_info.implementation_name;
+  }
+  static bool supports_native_handle(
+      const media::VideoEncoderInfo& video_encoder_info) {
+    return video_encoder_info.supports_native_handle;
+  }
+  static bool has_trusted_rate_controller(
+      const media::VideoEncoderInfo& video_encoder_info) {
+    return video_encoder_info.has_trusted_rate_controller;
+  }
+  static bool is_hardware_accelerated(
+      const media::VideoEncoderInfo& video_encoder_info) {
+    return video_encoder_info.is_hardware_accelerated;
+  }
+  static bool supports_simulcast(
+      const media::VideoEncoderInfo& video_encoder_info) {
+    return video_encoder_info.supports_simulcast;
+  }
+  static const media::ScalingSettings& scaling_settings(
+      const media::VideoEncoderInfo& video_encoder_info) {
+    return video_encoder_info.scaling_settings;
+  }
+  static base::span<const std::vector<uint8_t>,
+                    media::VideoEncoderInfo::kMaxSpatialLayers>
+  fps_allocation(const media::VideoEncoderInfo& video_encoder_info) {
+    return video_encoder_info.fps_allocation;
+  }
+  static const std::vector<media::ResolutionBitrateLimit>&
+  resolution_bitrate_limits(const media::VideoEncoderInfo& video_encoder_info) {
+    return video_encoder_info.resolution_bitrate_limits;
+  }
+
+  static bool Read(media::mojom::VideoEncoderInfoDataView data,
+                   media::VideoEncoderInfo* out);
+};
+
+}  // namespace mojo
+
+#endif  // MEDIA_MOJO_MOJOM_VIDEO_ENCODER_INFO_MOJOM_TRAITS_H_

media/mojo/mojom/video_encoder_info_mojom_traits_unittest.cc

+// Copyright 2019 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 "media/mojo/mojom/video_encoder_info_mojom_traits.h"
+
+#include "media/video/video_encoder_info.h"
+
+#include "mojo/public/cpp/test_support/test_utils.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+
+// These binary operators are implemented here because they are used in this
+// unittest. They cannot be enclosed by anonymous namespace, because they must
+// be visible by gtest in linking.
+bool operator==(const ::media::ScalingSettings& l,
+                const ::media::ScalingSettings& r) {
+  return l.min_qp == r.min_qp && l.max_qp == r.max_qp;
+}
+
+bool operator!=(const ::media::ScalingSettings& l,
+                const ::media::ScalingSettings& r) {
+  return !(l == r);
+}
+
+bool operator==(const ::media::ResolutionBitrateLimit& l,
+                const ::media::ResolutionBitrateLimit& r) {
+  return (l.frame_size == r.frame_size &&
+          l.min_start_bitrate_bps == r.min_start_bitrate_bps &&
+          l.min_bitrate_bps == r.min_bitrate_bps &&
+          l.max_bitrate_bps == r.max_bitrate_bps);
+}
+
+bool operator!=(const ::media::ResolutionBitrateLimit& l,
+                const ::media::ResolutionBitrateLimit& r) {
+  return !(l == r);
+}
+
+bool operator==(const ::media::VideoEncoderInfo& l,
+                const ::media::VideoEncoderInfo& r) {
+  if (l.implementation_name != r.implementation_name)
+    return false;
+  if (l.supports_native_handle != r.supports_native_handle)
+    return false;
+  if (l.has_trusted_rate_controller != r.has_trusted_rate_controller)
+    return false;
+  if (l.is_hardware_accelerated != r.is_hardware_accelerated)
+    return false;
+  if (l.supports_simulcast != r.supports_simulcast)
+    return false;
+  if (l.scaling_settings != r.scaling_settings)
+    return false;
+  for (size_t i = 0; i < ::media::VideoEncoderInfo::kMaxSpatialLayers; ++i) {
+    if (l.fps_allocation[i] != r.fps_allocation[i])
+      return false;
+  }
+  if (l.resolution_bitrate_limits != r.resolution_bitrate_limits)
+    return false;
+  return true;
+}
+
+TEST(VideoEncoderInfoStructTraitTest, RoundTrip) {
+  ::media::VideoEncoderInfo input;
+  input.implementation_name = "FakeVideoEncodeAccelerator";
+  // Scaling settings.
+  input.scaling_settings.min_qp = 12;
+  input.scaling_settings.max_qp = 123;
+  // FPS allocation.
+  for (size_t i = 0; i < ::media::VideoEncoderInfo::kMaxSpatialLayers; ++i)
+    input.fps_allocation[i] = {5, 5, 10};
+  // Resolution bitrate limits.
+  input.resolution_bitrate_limits.push_back(::media::ResolutionBitrateLimit(
+      gfx::Size(123, 456), 123456, 123456, 789012));
+  input.resolution_bitrate_limits.push_back(::media::ResolutionBitrateLimit(
+      gfx::Size(789, 1234), 1234567, 1234567, 7890123));
+  // Other bool values.
+  input.supports_native_handle = true;
+  input.has_trusted_rate_controller = true;
+  input.is_hardware_accelerated = true;
+  input.supports_simulcast = true;
+
+  ::media::VideoEncoderInfo output = input;
+  ASSERT_TRUE(mojo::test::SerializeAndDeserialize<mojom::VideoEncoderInfo>(
+      &input, &output));
+  EXPECT_EQ(input, output);
+}
+}  // namespace media

media/mojo/services/mojo_video_encode_accelerator_service.cc

@@ -10,6 +10,7 @@
 #include "base/logging.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/limits.h"
+#include "media/mojo/mojom/video_encoder_info.mojom.h"
 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 
@@ -195,4 +196,14 @@ void MojoVideoEncodeAcceleratorService::NotifyError(
   vea_client_->NotifyError(error);
 }
 
+void MojoVideoEncodeAcceleratorService::NotifyEncoderInfoChange(
+    const ::media::VideoEncoderInfo& info) {
+  DVLOG(4) << __func__;
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  if (!vea_client_)
+    return;
+
+  vea_client_->NotifyEncoderInfoChange(info);
+}
+
 }  // namespace media

media/mojo/services/mojo_video_encode_accelerator_service.h

@@ -78,6 +78,7 @@ class MEDIA_MOJO_EXPORT MojoVideoEncodeAcceleratorService
       int32_t bitstream_buffer_id,
       const media::BitstreamBufferMetadata& metadata) override;
   void NotifyError(::media::VideoEncodeAccelerator::Error error) override;
+  void NotifyEncoderInfoChange(const ::media::VideoEncoderInfo& info) override;
 
   const CreateAndInitializeVideoEncodeAcceleratorCallback create_vea_callback_;
   const gpu::GpuPreferences& gpu_preferences_;

media/mojo/services/mojo_video_encode_accelerator_service_unittest.cc

@@ -54,6 +54,7 @@ class MockMojoVideoEncodeAcceleratorClient
   MOCK_METHOD2(BitstreamBufferReady,
                void(int32_t, const media::BitstreamBufferMetadata&));
   MOCK_METHOD1(NotifyError, void(VideoEncodeAccelerator::Error));
+  MOCK_METHOD1(NotifyEncoderInfoChange, void(const VideoEncoderInfo& info));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockMojoVideoEncodeAcceleratorClient);

media/mojo/test/mojo_video_encode_accelerator_integration_test.cc

@@ -54,6 +54,8 @@ class MockVideoEncodeAcceleratorClient : public VideoEncodeAccelerator::Client {
   MOCK_METHOD2(BitstreamBufferReady,
                void(int32_t, const media::BitstreamBufferMetadata&));
   MOCK_METHOD1(NotifyError, void(VideoEncodeAccelerator::Error));
+  MOCK_METHOD1(NotifyEncoderInfoChange,
+               void(const media::VideoEncoderInfo& info));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockVideoEncodeAcceleratorClient);