Add support for configuring content type for VideoEncodeAccelerators

Bug: chromium:853185
Change-Id: I5e0a76e83318d7761d9d010b0083abc048f563e4
Reviewed-on: https://chromium-review.googlesource.com/1183665
Commit-Queue: Erik Språng <sprang@chromium.org>
Reviewed-by: Miguel Casas <mcasas@chromium.org>
Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#588358}

media/mojo/clients/mojo_video_encode_accelerator_unittest.cc

@@ -46,15 +46,17 @@ class MockMojoVideoEncodeAccelerator : public mojom::VideoEncodeAccelerator {
                                        allocation_size);
 
       DoInitialize(config.input_format, config.input_visible_size,
-                   config.output_profile, config.initial_bitrate, &client);
+                   config.output_profile, config.initial_bitrate,
+                   config.content_type, &client);
     }
     std::move(success_callback).Run(initialization_success_);
   }
-  MOCK_METHOD5(DoInitialize,
+  MOCK_METHOD6(DoInitialize,
                void(media::VideoPixelFormat,
                     const gfx::Size&,
                     media::VideoCodecProfile,
                     uint32_t,
+                    media::VideoEncodeAccelerator::Config::ContentType,
                     mojom::VideoEncodeAcceleratorClientPtr*));
 
   void Encode(const scoped_refptr<VideoFrame>& frame,
@@ -149,10 +151,12 @@ class MojoVideoEncodeAcceleratorTest : public ::testing::Test {
   void Initialize(MockVideoEncodeAcceleratorClient* mock_vea_client) {
     const VideoCodecProfile kOutputProfile = VIDEO_CODEC_PROFILE_UNKNOWN;
     const uint32_t kInitialBitrate = 100000u;
+    const VideoEncodeAccelerator::Config::ContentType kContentType =
+        VideoEncodeAccelerator::Config::ContentType::kDisplay;
 
     EXPECT_CALL(*mock_mojo_vea(),
                 DoInitialize(PIXEL_FORMAT_I420, kInputVisibleSize,
-                             kOutputProfile, kInitialBitrate, _));
+                             kOutputProfile, kInitialBitrate, kContentType, _));
     EXPECT_CALL(
         *mock_vea_client,
         RequireBitstreamBuffers(
@@ -160,7 +164,8 @@ class MojoVideoEncodeAcceleratorTest : public ::testing::Test {
             VideoFrame::AllocationSize(PIXEL_FORMAT_I420, kInputVisibleSize)));
 
     const VideoEncodeAccelerator::Config config(
-        PIXEL_FORMAT_I420, kInputVisibleSize, kOutputProfile, kInitialBitrate);
+        PIXEL_FORMAT_I420, kInputVisibleSize, kOutputProfile, kInitialBitrate,
+        base::nullopt, base::nullopt, kContentType);
     EXPECT_TRUE(mojo_vea()->Initialize(config, mock_vea_client));
     base::RunLoop().RunUntilIdle();
   }

media/mojo/interfaces/video_encode_accelerator.mojom

@@ -45,6 +45,12 @@ struct VideoBitrateAllocation {
 // This defines a mojo transport format for
 // media::VideoEncodeAccelerator::Config.
 struct VideoEncodeAcceleratorConfig {
+  // See media::VideoEncodeAccelerator::Config::ContentType
+  enum ContentType {
+    kCamera,
+    kDisplay
+  };
+
   VideoPixelFormat input_format;
   gfx.mojom.Size input_visible_size;
   VideoCodecProfile output_profile;
@@ -53,6 +59,7 @@ struct VideoEncodeAcceleratorConfig {
   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
+  ContentType content_type;
 };
 
 interface VideoEncodeAccelerator {

media/mojo/interfaces/video_encode_accelerator_mojom_traits.cc

@@ -116,6 +116,37 @@ bool StructTraits<media::mojom::Vp8MetadataDataView, media::Vp8Metadata>::Read(
   return true;
 }
 
+// static
+media::mojom::VideoEncodeAcceleratorConfig::ContentType
+EnumTraits<media::mojom::VideoEncodeAcceleratorConfig::ContentType,
+           media::VideoEncodeAccelerator::Config::ContentType>::
+    ToMojom(media::VideoEncodeAccelerator::Config::ContentType input) {
+  switch (input) {
+    case media::VideoEncodeAccelerator::Config::ContentType::kDisplay:
+      return media::mojom::VideoEncodeAcceleratorConfig::ContentType::kDisplay;
+    case media::VideoEncodeAccelerator::Config::ContentType::kCamera:
+      return media::mojom::VideoEncodeAcceleratorConfig::ContentType::kCamera;
+  }
+  NOTREACHED();
+  return media::mojom::VideoEncodeAcceleratorConfig::ContentType::kCamera;
+}
+// static
+bool EnumTraits<media::mojom::VideoEncodeAcceleratorConfig::ContentType,
+                media::VideoEncodeAccelerator::Config::ContentType>::
+    FromMojom(media::mojom::VideoEncodeAcceleratorConfig::ContentType input,
+              media::VideoEncodeAccelerator::Config::ContentType* output) {
+  switch (input) {
+    case media::mojom::VideoEncodeAcceleratorConfig::ContentType::kCamera:
+      *output = media::VideoEncodeAccelerator::Config::ContentType::kCamera;
+      return true;
+    case media::mojom::VideoEncodeAcceleratorConfig::ContentType::kDisplay:
+      *output = media::VideoEncodeAccelerator::Config::ContentType::kDisplay;
+      return true;
+  }
+  NOTREACHED();
+  return false;
+}
+
 // static
 bool StructTraits<media::mojom::VideoEncodeAcceleratorConfigDataView,
                   media::VideoEncodeAccelerator::Config>::
@@ -134,18 +165,20 @@ bool StructTraits<media::mojom::VideoEncodeAcceleratorConfigDataView,
     return false;
 
   base::Optional<uint32_t> initial_framerate;
-  if (input.has_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()) {
+  if (input.has_h264_output_level())
     h264_output_level = input.h264_output_level();
-  }
+
+  media::VideoEncodeAccelerator::Config::ContentType content_type;
+  if (!input.ReadContentType(&content_type))
+    return false;
 
   *output = media::VideoEncodeAccelerator::Config(
       input_format, input_visible_size, output_profile, input.initial_bitrate(),
-      initial_framerate, h264_output_level);
+      initial_framerate, h264_output_level, content_type);
   return true;
 }
 

media/mojo/interfaces/video_encode_accelerator_mojom_traits.h

@@ -75,6 +75,17 @@ class StructTraits<media::mojom::Vp8MetadataDataView, media::Vp8Metadata> {
                    media::Vp8Metadata* out_metadata);
 };
 
+template <>
+struct EnumTraits<media::mojom::VideoEncodeAcceleratorConfig::ContentType,
+                  media::VideoEncodeAccelerator::Config::ContentType> {
+  static media::mojom::VideoEncodeAcceleratorConfig::ContentType ToMojom(
+      media::VideoEncodeAccelerator::Config::ContentType input);
+
+  static bool FromMojom(
+      media::mojom::VideoEncodeAcceleratorConfig::ContentType,
+      media::VideoEncodeAccelerator::Config::ContentType* output);
+};
+
 template <>
 struct StructTraits<media::mojom::VideoEncodeAcceleratorConfigDataView,
                     media::VideoEncodeAccelerator::Config> {
@@ -118,6 +129,11 @@ struct StructTraits<media::mojom::VideoEncodeAcceleratorConfigDataView,
     return input.h264_output_level.has_value();
   }
 
+  static media::VideoEncodeAccelerator::Config::ContentType content_type(
+      const media::VideoEncodeAccelerator::Config& input) {
+    return input.content_type;
+  }
+
   static bool Read(media::mojom::VideoEncodeAcceleratorConfigDataView input,
                    media::VideoEncodeAccelerator::Config* output);
 };

media/video/video_encode_accelerator.cc

@@ -27,7 +27,12 @@ BitstreamBufferMetadata::BitstreamBufferMetadata(size_t payload_size_bytes,
       timestamp(timestamp) {}
 BitstreamBufferMetadata::~BitstreamBufferMetadata() = default;
 
-VideoEncodeAccelerator::Config::Config() = default;
+VideoEncodeAccelerator::Config::Config()
+    : input_format(PIXEL_FORMAT_UNKNOWN),
+      output_profile(VIDEO_CODEC_PROFILE_UNKNOWN),
+      initial_bitrate(0),
+      content_type(ContentType::kCamera) {}
+
 VideoEncodeAccelerator::Config::Config(const Config& config) = default;
 
 VideoEncodeAccelerator::Config::Config(
@@ -36,13 +41,15 @@ VideoEncodeAccelerator::Config::Config(
     VideoCodecProfile output_profile,
     uint32_t initial_bitrate,
     base::Optional<uint32_t> initial_framerate,
-    base::Optional<uint8_t> h264_output_level)
+    base::Optional<uint8_t> h264_output_level,
+    ContentType content_type)
     : 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) {}
+      h264_output_level(h264_output_level),
+      content_type(content_type) {}
 
 VideoEncodeAccelerator::Config::~Config() = default;
 

media/video/video_encode_accelerator.h

@@ -95,6 +95,10 @@ class MEDIA_EXPORT VideoEncodeAccelerator {
 
   // Parameters required for VEA initialization.
   struct MEDIA_EXPORT Config {
+    // Indicates if video content should be treated as a "normal" camera feed
+    // or as generated (e.g. screen capture).
+    enum class ContentType { kCamera, kDisplay };
+
     Config();
     Config(const Config& config);
 
@@ -103,7 +107,8 @@ class MEDIA_EXPORT VideoEncodeAccelerator {
            VideoCodecProfile output_profile,
            uint32_t initial_bitrate,
            base::Optional<uint32_t> initial_framerate = base::nullopt,
-           base::Optional<uint8_t> h264_output_level = base::nullopt);
+           base::Optional<uint8_t> h264_output_level = base::nullopt,
+           ContentType content_type = ContentType::kCamera);
 
     ~Config();
 
@@ -133,6 +138,13 @@ class MEDIA_EXPORT VideoEncodeAccelerator {
     // |h264_output_level|=9 for Level 1b, which should set level_idc to 11 and
     // constraint_set3_flag to 1. (Spec A.3.1 and A.3.2)
     base::Optional<uint8_t> h264_output_level;
+
+    // Indicates captured video (from a camera) or generated (screen grabber).
+    // Screen content has a number of special properties such as lack of noise,
+    // burstiness of motion and requirements for readability of small text in
+    // bright colors. With this content hint the encoder may choose to optimize
+    // for the given use case.
+    ContentType content_type;
   };
 
   // Interface for clients that use VideoEncodeAccelerator. These callbacks will