cc: Unify all sources of color space for YUVVideoDrawQuad

cc/resources/video_resource_updater.cc

 // Copyright 2013 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 "cc/resources/video_resource_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bit_cast.h"
+#include "base/feature_list.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/paint/skia_paint_canvas.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/resource_util.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "media/base/media_switches.h"
 #include "media/base/video_frame.h"
 #include "media/renderers/skcanvas_video_renderer.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 
@@ skipping 342 matching lines @@
 VideoResourceUpdater::NewHalfFloatMaker(int bits_per_channel) {
   if (bits_per_channel < 11) {
     return std::unique_ptr<VideoResourceUpdater::HalfFloatMaker>(
         new HalfFloatMaker_xor(bits_per_channel));
   } else {
     return std::unique_ptr<VideoResourceUpdater::HalfFloatMaker>(
         new HalfFloatMaker_libyuv(bits_per_channel));
   }
 }
 
+gfx::ColorSpace VideoResourceUpdater::GetColorSpace(
+    media::VideoFrame* video_frame) {
+  int videoframe_color_space;
+  if (video_frame->metadata()->GetInteger(
+          media::VideoFrameMetadata::COLOR_SPACE, &videoframe_color_space)) {
+    if (videoframe_color_space == media::COLOR_SPACE_JPEG) {
+      return gfx::ColorSpace::CreateJpeg();
+    } else if (videoframe_color_space == media::COLOR_SPACE_HD_REC709) {
+      return gfx::ColorSpace::CreateREC709();
+    }
+  }
+  return gfx::ColorSpace::CreateREC601();
+}
+
 VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
     scoped_refptr<media::VideoFrame> video_frame) {
   TRACE_EVENT0("cc", "VideoResourceUpdater::CreateForSoftwarePlanes");
   const media::VideoPixelFormat input_frame_format = video_frame->format();
 
   int bits_per_channel = video_frame->BitsPerChannel(input_frame_format);
 
   // Only YUV and Y16 software video frames are supported.
   DCHECK(media::IsYuvPlanar(input_frame_format) ||
          input_frame_format == media::PIXEL_FORMAT_Y16);
@@ skipping 125 matching lines @@
   }
 
   std::unique_ptr<HalfFloatMaker> half_float_maker;
   if (resource_provider_->YuvResourceFormat(bits_per_channel) ==
       LUMINANCE_F16) {
     half_float_maker = NewHalfFloatMaker(bits_per_channel);
     external_resources.offset = half_float_maker->Offset();
     external_resources.multiplier = half_float_maker->Multiplier();
   }
 
+  if (!base::FeatureList::IsEnabled(media::kVideoColorManagement))
+    output_color_space = GetColorSpace(video_frame.get());
+
   for (size_t i = 0; i < plane_resources.size(); ++i) {
     PlaneResource& plane_resource = *plane_resources[i];
     // Update each plane's resource id with its content.
     DCHECK_EQ(plane_resource.resource_format(),
               resource_provider_->YuvResourceFormat(bits_per_channel));
 
     if (!plane_resource.Matches(video_frame->unique_id(), i)) {
       // TODO(hubbe): Move all conversion (and upload?) code to media/.
       // We need to transfer data from |video_frame| to the plane resource.
       // TODO(reveman): Can use GpuMemoryBuffers here to improve performance.
@@ skipping 167 matching lines @@
     external_resources.read_lock_fences_enabled = true;
   }
   gfx::ColorSpace resource_color_space = video_frame->ColorSpace();
 
   external_resources.type = ResourceTypeForVideoFrame(video_frame.get());
   if (external_resources.type == VideoFrameExternalResources::NONE) {
     DLOG(ERROR) << "Unsupported Texture format"
                 << media::VideoPixelFormatToString(video_frame->format());
     return external_resources;
   }
-  if (external_resources.type == VideoFrameExternalResources::YUV_RESOURCE)
+  if (external_resources.type == VideoFrameExternalResources::YUV_RESOURCE) {
     resource_color_space = resource_color_space.GetAsFullRangeRGB();
+    if (!base::FeatureList::IsEnabled(media::kVideoColorManagement))
+      resource_color_space = GetColorSpace(video_frame.get());
+  }
 
   const size_t num_planes = media::VideoFrame::NumPlanes(video_frame->format());
   for (size_t i = 0; i < num_planes; ++i) {
     const gpu::MailboxHolder& mailbox_holder = video_frame->mailbox_holder(i);
     if (mailbox_holder.mailbox.IsZero())
       break;
 
     if (video_frame->metadata()->IsTrue(
             media::VideoFrameMetadata::COPY_REQUIRED)) {
       CopyPlaneTexture(video_frame.get(), resource_color_space, mailbox_holder,
@@ skipping 48 matching lines @@
   if (lost_resource) {
     resource_it->clear_refs();
     updater->DeleteResource(resource_it);
     return;
   }
 
   resource_it->remove_ref();
 }
 
 }  // namespace cc