[media] Plumb |target_color_space| to VdaVideoDecoder.

Bug: 842276
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: Ibbbca8f7714b644034aa4b95fa444c9c51f973c7
Reviewed-on: https://chromium-review.googlesource.com/1056364Reviewed-by: Xiaohan Wang <xhwang@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Commit-Queue: Dan Sanders <sandersd@chromium.org>
Cr-Commit-Position: refs/heads/master@{#558514}

media/base/decoder_factory.cc

@@ -21,6 +21,7 @@ void DecoderFactory::CreateVideoDecoders(
     GpuVideoAcceleratorFactories* gpu_factories,
     MediaLog* media_log,
     const RequestOverlayInfoCB& request_overlay_info_cb,
+    const gfx::ColorSpace& target_color_space,
     std::vector<std::unique_ptr<VideoDecoder>>* video_decoders) {}
 
 }  // namespace media

media/base/decoder_factory.h

@@ -15,7 +15,11 @@
 
 namespace base {
 class SingleThreadTaskRunner;
-}
+}  // namespace base
+
+namespace gfx {
+class ColorSpace;
+}  // namespace gfx
 
 namespace media {
 
@@ -43,6 +47,7 @@ class MEDIA_EXPORT DecoderFactory {
       GpuVideoAcceleratorFactories* gpu_factories,
       MediaLog* media_log,
       const RequestOverlayInfoCB& request_overlay_info_cb,
+      const gfx::ColorSpace& target_color_space,
       std::vector<std::unique_ptr<VideoDecoder>>* video_decoders);
 
  private:

media/gpu/ipc/service/vda_video_decoder.cc

@@ -105,6 +105,7 @@ VdaVideoDecoder::Create(
     scoped_refptr<base::SingleThreadTaskRunner> parent_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner,
     MediaLog* media_log,
+    const gfx::ColorSpace& target_color_space,
     const gpu::GpuPreferences& gpu_preferences,
     const gpu::GpuDriverBugWorkarounds& gpu_workarounds,
     GetStubCB get_stub_cb) {
@@ -114,7 +115,7 @@ VdaVideoDecoder::Create(
   std::unique_ptr<VdaVideoDecoder, std::default_delete<VideoDecoder>> ptr(
       new VdaVideoDecoder(
           std::move(parent_task_runner), std::move(gpu_task_runner), media_log,
-          base::BindOnce(&PictureBufferManager::Create),
+          target_color_space, base::BindOnce(&PictureBufferManager::Create),
           base::BindOnce(&CreateCommandBufferHelper, std::move(get_stub_cb)),
           base::BindOnce(&CreateAndInitializeVda, gpu_preferences,
                          gpu_workarounds),
@@ -124,12 +125,11 @@ VdaVideoDecoder::Create(
   return ptr;
 }
 
-// TODO(sandersd): Take and use a MediaLog. This will require making
-// MojoMediaLog threadsafe.
 VdaVideoDecoder::VdaVideoDecoder(
     scoped_refptr<base::SingleThreadTaskRunner> parent_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner,
     MediaLog* media_log,
+    const gfx::ColorSpace& target_color_space,
     CreatePictureBufferManagerCB create_picture_buffer_manager_cb,
     CreateCommandBufferHelperCB create_command_buffer_helper_cb,
     CreateAndInitializeVdaCB create_and_initialize_vda_cb,
@@ -137,6 +137,7 @@ VdaVideoDecoder::VdaVideoDecoder(
     : parent_task_runner_(std::move(parent_task_runner)),
       gpu_task_runner_(std::move(gpu_task_runner)),
       media_log_(media_log),
+      target_color_space_(target_color_space),
       create_command_buffer_helper_cb_(
           std::move(create_command_buffer_helper_cb)),
       create_and_initialize_vda_cb_(std::move(create_and_initialize_vda_cb)),
@@ -298,8 +299,7 @@ void VdaVideoDecoder::InitializeOnGpuThread() {
   vda_config.is_deferred_initialization_allowed = false;
   vda_config.initial_expected_coded_size = config_.coded_size();
   vda_config.container_color_space = config_.color_space_info();
-  // TODO(sandersd): Plumb |target_color_space| from DefaultRenderFactory.
-  // vda_config.target_color_space = [...];
+  vda_config.target_color_space = target_color_space_;
   vda_config.hdr_metadata = config_.hdr_metadata();
   // vda_config.sps = [Only used by AVDA]
   // vda_config.pps = [Only used by AVDA]

media/gpu/ipc/service/vda_video_decoder.h

@@ -23,6 +23,7 @@
 #include "media/gpu/command_buffer_helper.h"
 #include "media/gpu/ipc/service/picture_buffer_manager.h"
 #include "media/video/video_decode_accelerator.h"
+#include "ui/gfx/color_space.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_bindings.h"
 
@@ -69,6 +70,7 @@ class VdaVideoDecoder : public VideoDecoder,
   Create(scoped_refptr<base::SingleThreadTaskRunner> parent_task_runner,
          scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner,
          MediaLog* media_log,
+         const gfx::ColorSpace& target_color_space,
          const gpu::GpuPreferences& gpu_preferences,
          const gpu::GpuDriverBugWorkarounds& gpu_workarounds,
          GetStubCB get_stub_cb);
@@ -80,6 +82,7 @@ class VdaVideoDecoder : public VideoDecoder,
   //     called on (should be the GPU main thread).
   // |media_log|: MediaLog object to log to; must live at least until
   //     Destroy() returns.
+  // |target_color_space|: Color space of the output device.
   // |create_picture_buffer_manager_cb|: PictureBufferManager factory.
   // |create_command_buffer_helper_cb|: CommandBufferHelper factory.
   // |create_and_initialize_vda_cb|: VideoDecodeAccelerator factory.
@@ -89,6 +92,7 @@ class VdaVideoDecoder : public VideoDecoder,
       scoped_refptr<base::SingleThreadTaskRunner> parent_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner,
       MediaLog* media_log,
+      const gfx::ColorSpace& target_color_space,
       CreatePictureBufferManagerCB create_picture_buffer_manager_cb,
       CreateCommandBufferHelperCB create_command_buffer_helper_cb,
       CreateAndInitializeVdaCB create_and_initialize_vda_cb,
@@ -166,6 +170,7 @@ class VdaVideoDecoder : public VideoDecoder,
   scoped_refptr<base::SingleThreadTaskRunner> parent_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner_;
   MediaLog* media_log_;
+  gfx::ColorSpace target_color_space_;
   scoped_refptr<PictureBufferManager> picture_buffer_manager_;
   CreateCommandBufferHelperCB create_command_buffer_helper_cb_;
   CreateAndInitializeVdaCB create_and_initialize_vda_cb_;

media/gpu/ipc/service/vda_video_decoder_unittest.cc

@@ -27,6 +27,7 @@
 #include "media/video/mock_video_decode_accelerator.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/color_space.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
@@ -109,7 +110,7 @@ class VdaVideoDecoderTest : public testing::Test {
     EXPECT_CALL(*vda_, Destroy());
 
     vdavd_.reset(new VdaVideoDecoder(
-        task_runner, task_runner, &media_log_,
+        task_runner, task_runner, &media_log_, gfx::ColorSpace(),
         base::BindOnce(&VdaVideoDecoderTest::CreatePictureBufferManager,
                        base::Unretained(this)),
         base::BindOnce(&VdaVideoDecoderTest::CreateCommandBufferHelper,

media/mojo/clients/mojo_decoder_factory.cc

@@ -44,6 +44,7 @@ void MojoDecoderFactory::CreateVideoDecoders(
     GpuVideoAcceleratorFactories* gpu_factories,
     MediaLog* media_log,
     const RequestOverlayInfoCB& request_overlay_info_cb,
+    const gfx::ColorSpace& target_color_space,
     std::vector<std::unique_ptr<VideoDecoder>>* video_decoders) {
 #if BUILDFLAG(ENABLE_MOJO_VIDEO_DECODER)
   // If MojoVideoDecoder is not enabled, then return without adding anything.
@@ -54,7 +55,7 @@ void MojoDecoderFactory::CreateVideoDecoders(
 
   video_decoders->push_back(std::make_unique<MojoVideoDecoder>(
       task_runner, gpu_factories, media_log, std::move(video_decoder_ptr),
-      request_overlay_info_cb));
+      request_overlay_info_cb, target_color_space));
 #endif
 }
 

media/mojo/clients/mojo_decoder_factory.h

@@ -30,6 +30,7 @@ class MojoDecoderFactory : public DecoderFactory {
       GpuVideoAcceleratorFactories* gpu_factories,
       MediaLog* media_log,
       const RequestOverlayInfoCB& request_overlay_info_cb,
+      const gfx::ColorSpace& target_color_space,
       std::vector<std::unique_ptr<VideoDecoder>>* video_decoders) final;
 
  private:

media/mojo/clients/mojo_video_decoder.cc

@@ -77,7 +77,8 @@ MojoVideoDecoder::MojoVideoDecoder(
     GpuVideoAcceleratorFactories* gpu_factories,
     MediaLog* media_log,
     mojom::VideoDecoderPtr remote_decoder,
-    const RequestOverlayInfoCB& request_overlay_info_cb)
+    const RequestOverlayInfoCB& request_overlay_info_cb,
+    const gfx::ColorSpace& target_color_space)
     : task_runner_(task_runner),
       remote_decoder_info_(remote_decoder.PassInterface()),
       gpu_factories_(gpu_factories),
@@ -87,6 +88,7 @@ MojoVideoDecoder::MojoVideoDecoder(
       media_log_service_(media_log),
       media_log_binding_(&media_log_service_),
       request_overlay_info_cb_(request_overlay_info_cb),
+      target_color_space_(target_color_space),
       weak_factory_(this) {
   DVLOG(1) << __func__;
   weak_this_ = weak_factory_.GetWeakPtr();
@@ -304,10 +306,11 @@ void MojoVideoDecoder::BindRemoteDecoder() {
     }
   }
 
-  remote_decoder_->Construct(
-      std::move(client_ptr_info), std::move(media_log_ptr_info),
-      std::move(video_frame_handle_releaser_request),
-      std::move(remote_consumer_handle), std::move(command_buffer_id));
+  remote_decoder_->Construct(std::move(client_ptr_info),
+                             std::move(media_log_ptr_info),
+                             std::move(video_frame_handle_releaser_request),
+                             std::move(remote_consumer_handle),
+                             std::move(command_buffer_id), target_color_space_);
 }
 
 void MojoVideoDecoder::RequestOverlayInfo(bool restart_for_transitions) {

media/mojo/clients/mojo_video_decoder.h

@@ -14,6 +14,7 @@
 #include "media/mojo/interfaces/video_decoder.mojom.h"
 #include "media/video/video_decode_accelerator.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
+#include "ui/gfx/color_space.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ -37,7 +38,8 @@ class MojoVideoDecoder final : public VideoDecoder,
                    GpuVideoAcceleratorFactories* gpu_factories,
                    MediaLog* media_log,
                    mojom::VideoDecoderPtr remote_decoder,
-                   const RequestOverlayInfoCB& request_overlay_info_cb);
+                   const RequestOverlayInfoCB& request_overlay_info_cb,
+                   const gfx::ColorSpace& target_color_space);
   ~MojoVideoDecoder() final;
 
   // VideoDecoder implementation.
@@ -112,6 +114,7 @@ class MojoVideoDecoder final : public VideoDecoder,
   mojo::AssociatedBinding<mojom::MediaLog> media_log_binding_;
   RequestOverlayInfoCB request_overlay_info_cb_;
   bool overlay_info_requested_ = false;
+  gfx::ColorSpace target_color_space_;
 
   bool initialized_ = false;
   bool needs_bitstream_conversion_ = false;

media/mojo/interfaces/BUILD.gn

@@ -52,6 +52,7 @@ mojom("interfaces") {
     "//mojo/public/mojom/base",
     "//services/service_manager/public/mojom",
     "//ui/gfx/geometry/mojo",
+    "//ui/gfx/mojo",
     "//url/mojom:url_mojom_gurl",
     "//url/mojom:url_mojom_origin",
   ]

media/mojo/interfaces/video_decoder.mojom

@@ -8,6 +8,7 @@ import "gpu/ipc/common/sync_token.mojom";
 import "media/mojo/interfaces/media_log.mojom";
 import "media/mojo/interfaces/media_types.mojom";
 import "mojo/public/mojom/base/unguessable_token.mojom";
+import "ui/gfx/mojo/color_space.mojom";
 
 // Identifies a CommandBufferStub. MediaGpuChannelManager is responsible
 // for minting |channel_token| values.
@@ -60,7 +61,8 @@ interface VideoDecoder {
             associated MediaLog media_log,
             VideoFrameHandleReleaser& video_frame_handle_releaser,
             handle<data_pipe_consumer> decoder_buffer_pipe,
-            CommandBufferId? command_buffer_id);
+            CommandBufferId? command_buffer_id,
+            gfx.mojom.ColorSpace target_color_space);
 
   // Configure (or reconfigure) the decoder. This must be called before decoding
   // any frames, and must not be called while there are pending Initialize(),

media/mojo/services/gpu_mojo_media_client.cc

@@ -112,7 +112,8 @@ std::unique_ptr<VideoDecoder> GpuMojoMediaClient::CreateVideoDecoder(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     MediaLog* media_log,
     mojom::CommandBufferIdPtr command_buffer_id,
-    RequestOverlayInfoCB request_overlay_info_cb) {
+    RequestOverlayInfoCB request_overlay_info_cb,
+    const gfx::ColorSpace& target_color_space) {
   // Both MCVD and D3D11 VideoDecoders need a command buffer.
   if (!command_buffer_id)
     return nullptr;
@@ -131,8 +132,8 @@ std::unique_ptr<VideoDecoder> GpuMojoMediaClient::CreateVideoDecoder(
                                               std::move(get_stub_cb)));
 #elif defined(OS_MACOSX)
   return VdaVideoDecoder::Create(
-      task_runner, gpu_task_runner_, media_log, gpu_preferences_,
-      gpu_workarounds_,
+      task_runner, gpu_task_runner_, media_log, target_color_space,
+      gpu_preferences_, gpu_workarounds_,
       base::BindRepeating(&GetCommandBufferStub, media_gpu_channel_manager_,
                           command_buffer_id->channel_token,
                           command_buffer_id->route_id));

media/mojo/services/gpu_mojo_media_client.h

@@ -44,7 +44,8 @@ class GpuMojoMediaClient : public MojoMediaClient {
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       MediaLog* media_log,
       mojom::CommandBufferIdPtr command_buffer_id,
-      RequestOverlayInfoCB request_overlay_info_cb) final;
+      RequestOverlayInfoCB request_overlay_info_cb,
+      const gfx::ColorSpace& target_color_space) final;
   std::unique_ptr<CdmFactory> CreateCdmFactory(
       service_manager::mojom::InterfaceProvider* interface_provider) final;
 #if BUILDFLAG(ENABLE_LIBRARY_CDMS)

media/mojo/services/mojo_media_client.cc

@@ -32,7 +32,8 @@ std::unique_ptr<VideoDecoder> MojoMediaClient::CreateVideoDecoder(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     MediaLog* media_log,
     mojom::CommandBufferIdPtr command_buffer_id,
-    RequestOverlayInfoCB request_overlay_info_cb) {
+    RequestOverlayInfoCB request_overlay_info_cb,
+    const gfx::ColorSpace& target_color_space) {
   return nullptr;
 }
 

media/mojo/services/mojo_media_client.h

@@ -18,13 +18,17 @@
 
 namespace base {
 class SingleThreadTaskRunner;
-}
+}  // namespace base
+
+namespace gfx {
+class ColorSpace;
+}  // namespace gfx
 
 namespace service_manager {
 class Connector;
 namespace mojom {
 class InterfaceProvider;
-}
+}  // namespace mojom
 }  // namespace service_manager
 
 namespace media {
@@ -54,7 +58,8 @@ class MEDIA_MOJO_EXPORT MojoMediaClient {
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       MediaLog* media_log,
       mojom::CommandBufferIdPtr command_buffer_id,
-      RequestOverlayInfoCB request_overlay_info_cb);
+      RequestOverlayInfoCB request_overlay_info_cb,
+      const gfx::ColorSpace& target_color_space);
 
   // Returns the Renderer to be used by MojoRendererService.
   // TODO(hubbe): Find out whether we should pass in |target_color_space| here.

media/mojo/services/mojo_video_decoder_service.cc

@@ -113,7 +113,8 @@ void MojoVideoDecoderService::Construct(
     mojom::MediaLogAssociatedPtrInfo media_log,
     mojom::VideoFrameHandleReleaserRequest video_frame_handle_releaser,
     mojo::ScopedDataPipeConsumerHandle decoder_buffer_pipe,
-    mojom::CommandBufferIdPtr command_buffer_id) {
+    mojom::CommandBufferIdPtr command_buffer_id,
+    const gfx::ColorSpace& target_color_space) {
   DVLOG(1) << __func__;
 
   if (decoder_) {
@@ -139,7 +140,8 @@ void MojoVideoDecoderService::Construct(
       base::ThreadTaskRunnerHandle::Get(), media_log_.get(),
       std::move(command_buffer_id),
       base::Bind(&MojoVideoDecoderService::OnDecoderRequestedOverlayInfo,
-                 weak_this_));
+                 weak_this_),
+      target_color_space);
 }
 
 void MojoVideoDecoderService::Initialize(const VideoDecoderConfig& config,

media/mojo/services/mojo_video_decoder_service.h

@@ -46,7 +46,8 @@ class MEDIA_MOJO_EXPORT MojoVideoDecoderService final
       mojom::MediaLogAssociatedPtrInfo media_log,
       mojom::VideoFrameHandleReleaserRequest video_frame_handle_releaser,
       mojo::ScopedDataPipeConsumerHandle decoder_buffer_pipe,
-      mojom::CommandBufferIdPtr command_buffer_id) final;
+      mojom::CommandBufferIdPtr command_buffer_id,
+      const gfx::ColorSpace& target_color_space) final;
   void Initialize(const VideoDecoderConfig& config,
                   bool low_delay,
                   int32_t cdm_id,

media/mojo/test/mojo_video_decoder_integration_test.cc

@@ -33,6 +33,7 @@
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/color_space.h"
 
 using ::testing::_;
 using ::testing::AtLeast;
@@ -159,7 +160,8 @@ class FakeMojoMediaClient : public MojoMediaClient {
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       MediaLog* media_log,
       mojom::CommandBufferIdPtr command_buffer_id,
-      RequestOverlayInfoCB request_overlay_info_cb) override {
+      RequestOverlayInfoCB request_overlay_info_cb,
+      const gfx::ColorSpace& target_color_space) override {
     return create_video_decoder_cb_.Run(media_log);
   }
 
@@ -184,7 +186,8 @@ class MojoVideoDecoderIntegrationTest : public ::testing::Test {
         mojo::MakeRequest(&remote_video_decoder));
     client_ = std::make_unique<MojoVideoDecoder>(
         base::ThreadTaskRunnerHandle::Get(), nullptr, &client_media_log_,
-        std::move(remote_video_decoder), RequestOverlayInfoCB());
+        std::move(remote_video_decoder), RequestOverlayInfoCB(),
+        gfx::ColorSpace());
   }
 
   void TearDown() override {

media/renderers/default_renderer_factory.cc

@@ -109,9 +109,9 @@ DefaultRendererFactory::CreateVideoDecoders(
     DCHECK_EQ(gpu_factories->GetTaskRunner(), media_task_runner);
 
     if (decoder_factory_) {
-      decoder_factory_->CreateVideoDecoders(media_task_runner, gpu_factories,
-                                            media_log_, request_overlay_info_cb,
-                                            &video_decoders);
+      decoder_factory_->CreateVideoDecoders(
+          media_task_runner, gpu_factories, media_log_, request_overlay_info_cb,
+          target_color_space, &video_decoders);
     }
 
     // MojoVideoDecoder replaces any VDA for this platform when it's enabled.