Plumb color_space and hdr_metadata to media_codec_bridge_impl

For taking the VP9 HDR metadata from the video container and passes it to MediaCodec
Reference for packing HDR metadata in MediaFormat:
https://github.com/google/ExoPlayer/pull/2729/commits/e93ce41a285fe6b0493faa91523b010469591be7

Bug: internal b/68950223
Test: none
Change-Id: Id2b83c98a0844832f3bdfae7e3bd1dfa9c3728dc
Reviewed-on: https://chromium-review.googlesource.com/755952Reviewed-by: Fredrik Hubinette <hubbe@chromium.org>
Reviewed-by: Robert Sesek <rsesek@chromium.org>
Reviewed-by: Sergey Volk <servolk@chromium.org>
Commit-Queue: Sandeep Vijayasekar <sandv@chromium.org>
Cr-Commit-Position: refs/heads/master@{#521100}

media/base/android/media_codec_bridge_impl.cc

@@ -240,6 +240,8 @@ std::unique_ptr<MediaCodecBridge> MediaCodecBridgeImpl::CreateVideoDecoder(
     const JavaRef<jobject>& media_crypto,
     const std::vector<uint8_t>& csd0,
     const std::vector<uint8_t>& csd1,
+    const VideoColorSpace& color_space,
+    const base::Optional<HDRMetadata>& hdr_metadata,
     bool allow_adaptive_playback) {
   if (!MediaCodecUtil::IsMediaCodecAvailable())
     return nullptr;

media/base/android/media_codec_bridge_impl.h

@@ -22,6 +22,9 @@
 
 namespace media {
 
+class VideoColorSpace;
+struct HDRMetadata;
+
 // A bridge to a Java MediaCodec.
 class MEDIA_EXPORT MediaCodecBridgeImpl : public MediaCodecBridge {
  public:
@@ -38,6 +41,8 @@ class MEDIA_EXPORT MediaCodecBridgeImpl : public MediaCodecBridge {
       // Codec specific data. See MediaCodec docs.
       const std::vector<uint8_t>& csd0,
       const std::vector<uint8_t>& csd1,
+      const VideoColorSpace& color_space,
+      const base::Optional<HDRMetadata>& hdr_metadata,
       // Should adaptive playback be allowed if supported.
       bool allow_adaptive_playback = true);
 

media/base/android/media_codec_bridge_impl_unittest.cc

@@ -293,7 +293,8 @@ TEST(MediaCodecBridgeTest, CreateH264Decoder) {
 
   MediaCodecBridgeImpl::CreateVideoDecoder(
       kCodecH264, CodecType::kAny, gfx::Size(640, 480), nullptr, nullptr,
-      std::vector<uint8_t>(), std::vector<uint8_t>());
+      std::vector<uint8_t>(), std::vector<uint8_t>(), VideoColorSpace(),
+      HDRMetadata());
 }
 
 TEST(MediaCodecBridgeTest, DoNormal) {
@@ -402,7 +403,8 @@ TEST(MediaCodecBridgeTest, PresentationTimestampsDoNotDecrease) {
   std::unique_ptr<MediaCodecBridge> media_codec(
       MediaCodecBridgeImpl::CreateVideoDecoder(
           kCodecVP8, CodecType::kAny, gfx::Size(320, 240), nullptr, nullptr,
-          std::vector<uint8_t>(), std::vector<uint8_t>()));
+          std::vector<uint8_t>(), std::vector<uint8_t>(), VideoColorSpace(),
+          HDRMetadata()));
   ASSERT_THAT(media_codec, NotNull());
   scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("vp8-I-frame-320x240");
   DecodeMediaFrame(media_codec.get(), buffer->data(), buffer->data_size(),
@@ -429,11 +431,11 @@ TEST(MediaCodecBridgeTest, CreateUnsupportedCodec) {
   EXPECT_THAT(MediaCodecBridgeImpl::CreateAudioDecoder(
                   NewAudioConfig(kUnknownAudioCodec), nullptr),
               IsNull());
-  EXPECT_THAT(
-      MediaCodecBridgeImpl::CreateVideoDecoder(
-          kUnknownVideoCodec, CodecType::kAny, gfx::Size(320, 240), nullptr,
-          nullptr, std::vector<uint8_t>(), std::vector<uint8_t>()),
-      IsNull());
+  EXPECT_THAT(MediaCodecBridgeImpl::CreateVideoDecoder(
+                  kUnknownVideoCodec, CodecType::kAny, gfx::Size(320, 240),
+                  nullptr, nullptr, std::vector<uint8_t>(),
+                  std::vector<uint8_t>(), VideoColorSpace(), HDRMetadata()),
+              IsNull());
 }
 
 // Test MediaCodec HW H264 encoding and validate the format of encoded frames.

media/base/android/mock_media_codec_bridge.cc

@@ -54,6 +54,8 @@ std::unique_ptr<MediaCodecBridge> MockMediaCodecBridge::CreateVideoDecoder(
     const base::android::JavaRef<jobject>& media_crypto,
     const std::vector<uint8_t>& csd0,
     const std::vector<uint8_t>& csd1,
+    const VideoColorSpace& color_space,
+    const base::Optional<HDRMetadata>& hdr_metadata,
     bool allow_adaptive_playback) {
   return base::MakeUnique<MockMediaCodecBridge>();
 }

media/base/android/mock_media_codec_bridge.h

@@ -8,6 +8,7 @@
 #include "base/android/scoped_java_ref.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/android/test_destruction_observable.h"
+#include "media/base/hdr_metadata.h"
 #include "media/base/video_codecs.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -85,6 +86,8 @@ class MockMediaCodecBridge : public MediaCodecBridge,
       const base::android::JavaRef<jobject>& media_crypto,
       const std::vector<uint8_t>& csd0,
       const std::vector<uint8_t>& csd1,
+      const VideoColorSpace& color_space,
+      const base::Optional<HDRMetadata>& hdr_metadata,
       bool allow_adaptive_playback);
 
  private:

media/base/ipc/media_param_traits_macros.h

@@ -19,6 +19,7 @@
 #include "media/base/demuxer_stream.h"
 #include "media/base/eme_constants.h"
 #include "media/base/encryption_scheme.h"
+#include "media/base/hdr_metadata.h"
 #include "media/base/media_log_event.h"
 #include "media/base/output_device_info.h"
 #include "media/base/overlay_info.h"
@@ -159,6 +160,21 @@ IPC_STRUCT_TRAITS_BEGIN(media::VideoColorSpace)
   IPC_STRUCT_TRAITS_MEMBER(range)
 IPC_STRUCT_TRAITS_END()
 
+IPC_STRUCT_TRAITS_BEGIN(media::MasteringMetadata)
+  IPC_STRUCT_TRAITS_MEMBER(primary_r)
+  IPC_STRUCT_TRAITS_MEMBER(primary_g)
+  IPC_STRUCT_TRAITS_MEMBER(primary_b)
+  IPC_STRUCT_TRAITS_MEMBER(white_point)
+  IPC_STRUCT_TRAITS_MEMBER(luminance_max)
+  IPC_STRUCT_TRAITS_MEMBER(luminance_min)
+IPC_STRUCT_TRAITS_END()
+
+IPC_STRUCT_TRAITS_BEGIN(media::HDRMetadata)
+  IPC_STRUCT_TRAITS_MEMBER(mastering_metadata)
+  IPC_STRUCT_TRAITS_MEMBER(max_content_light_level)
+  IPC_STRUCT_TRAITS_MEMBER(max_frame_average_light_level)
+IPC_STRUCT_TRAITS_END()
+
 IPC_STRUCT_TRAITS_BEGIN(media::OverlayInfo)
   IPC_STRUCT_TRAITS_MEMBER(surface_id)
   IPC_STRUCT_TRAITS_MEMBER(routing_token)

media/filters/gpu_video_decoder.cc

@@ -334,6 +334,7 @@ void GpuVideoDecoder::CompleteInitialization(const OverlayInfo& overlay_info) {
   vda_config.initial_expected_coded_size = config_.coded_size();
   vda_config.container_color_space = config_.color_space_info();
   vda_config.target_color_space = target_color_space_;
+  vda_config.hdr_metadata = config_.hdr_metadata();
 
 #if defined(OS_ANDROID) && BUILDFLAG(USE_PROPRIETARY_CODECS)
   // We pass the SPS and PPS on Android because it lets us initialize

media/gpu/android/android_video_decode_accelerator.cc

@@ -321,6 +321,9 @@ bool AndroidVideoDecodeAccelerator::Initialize(const Config& config,
     codec_config_->csd1 = config.pps;
   }
 
+  codec_config_->container_color_space = config.container_color_space;
+  codec_config_->hdr_metadata = config.hdr_metadata;
+
   // Only use MediaCodec for VP8/9 if it's likely backed by hardware
   // or if the stream is encrypted.
   if (IsMediaCodecSoftwareDecodingForbidden() &&

media/gpu/android/avda_codec_allocator.cc

@@ -62,7 +62,8 @@ std::unique_ptr<MediaCodecBridge> CreateMediaCodecInternal(
       codec_config->codec, codec_type,
       codec_config->initial_expected_coded_size,
       codec_config->surface_bundle->GetJavaSurface(), media_crypto,
-      codec_config->csd0, codec_config->csd1, true));
+      codec_config->csd0, codec_config->csd1,
+      codec_config->container_color_space, codec_config->hdr_metadata, true));
 
   return codec;
 }

media/gpu/android/avda_codec_allocator.h

@@ -73,6 +73,11 @@ class MEDIA_GPU_EXPORT CodecConfig
   std::vector<uint8_t> csd0;
   std::vector<uint8_t> csd1;
 
+  // VP9 HDR metadata is only embedded in the container
+  // HDR10 meta data is embedded in the video stream
+  VideoColorSpace container_color_space;
+  base::Optional<HDRMetadata> hdr_metadata;
+
  protected:
   friend class base::RefCountedThreadSafe<CodecConfig>;
   virtual ~CodecConfig();
@@ -127,6 +132,8 @@ class MEDIA_GPU_EXPORT AVDACodecAllocator {
           const base::android::JavaRef<jobject>& media_crypto,
           const std::vector<uint8_t>& csd0,
           const std::vector<uint8_t>& csd1,
+          const VideoColorSpace& color_space,
+          const base::Optional<HDRMetadata>& hdr_metadata,
           bool allow_adaptive_playback)>;
 
   // Make sure the construction threads are started for |client|.  If the

media/gpu/ipc/common/media_param_traits_macros.h

@@ -29,6 +29,7 @@ IPC_STRUCT_TRAITS_BEGIN(media::VideoDecodeAccelerator::Config)
   IPC_STRUCT_TRAITS_MEMBER(pps)
   IPC_STRUCT_TRAITS_MEMBER(container_color_space)
   IPC_STRUCT_TRAITS_MEMBER(target_color_space)
+  IPC_STRUCT_TRAITS_MEMBER(hdr_metadata)
 IPC_STRUCT_TRAITS_END()
 
 IPC_STRUCT_TRAITS_BEGIN(media::CreateVideoEncoderParams)

media/video/video_decode_accelerator.h

@@ -178,6 +178,9 @@ class MEDIA_EXPORT VideoDecodeAccelerator {
     // Used as a hint to the decoder. Outputting VideoFrames in this color space
     // may avoid extra conversion steps.
     gfx::ColorSpace target_color_space;
+
+    // HDR metadata specified by the container.
+    base::Optional<HDRMetadata> hdr_metadata;
   };
 
   // Interface for collaborating with picture interface to provide memory for