Pass YUV color space information to Skia in VideoImageGenerator.

media/filters/skcanvas_video_renderer.cc

 // Copyright (c) 2012 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/filters/skcanvas_video_renderer.h"
 
 #include "base/logging.h"
 #include "media/base/video_frame.h"
 #include "media/base/yuv_convert.h"
 #include "third_party/libyuv/include/libyuv.h"
@@ skipping 11 matching lines @@
     SK_A32_SHIFT == 24
 #define LIBYUV_I420_TO_ARGB libyuv::I420ToABGR
 #define LIBYUV_I422_TO_ARGB libyuv::I422ToABGR
 #else
 #error Unexpected Skia ARGB_8888 layout!
 #endif
 
 namespace media {
 
 static bool IsYUV(media::VideoFrame::Format format) {
   return format == media::VideoFrame::YV12 ||

[scherkus (not reviewing), 2014/09/16 00:35:08]

can we switch-ify this so we future proof the code?

[rileya (GONE FROM CHROMIUM), 2014/09/16 00:58:32]

Sgtm, done!

          format == media::VideoFrame::YV16 ||
          format == media::VideoFrame::I420 ||
          format == media::VideoFrame::YV12A ||
          format == media::VideoFrame::YV12J ||
          format == media::VideoFrame::YV24;
 }
 
 static bool IsYUVOrNative(media::VideoFrame::Format format) {
   return IsYUV(format) || format == media::VideoFrame::NATIVE_TEXTURE;
 }
@@ skipping 154 matching lines @@
     if (!pixels)
       return true;
     // If skia couldn't do the YUV conversion, we will.
     ConvertVideoFrameToRGBPixels(frame_, pixels, row_bytes);
     frame_ = NULL;
     return true;
   }
 
   virtual bool onGetYUV8Planes(SkISize sizes[3],
                                void* planes[3],
-                               size_t row_bytes[3]) OVERRIDE {
+                               size_t row_bytes[3],
+                               SkYUVColorSpace* colorSpace) OVERRIDE {

[scherkus (not reviewing), 2014/09/16 00:35:09]

color_space

[rileya (GONE FROM CHROMIUM), 2014/09/16 00:58:32]

Done.

     if (!frame_.get())
       return false;
-    // Currently Skia only supports JPEG color range YUV.
-    if (frame_->format() != VideoFrame::YV12J)
+
+    if (!IsYUV(frame_->format()))
       return false;
+
+    if (colorSpace) {

[scherkus (not reviewing), 2014/09/16 00:35:08]

can skia tighten up the API to guarantee this is always non-NULL? generally try
to avoid optional-ness whenever possible

[rileya (GONE FROM CHROMIUM), 2014/09/16 00:58:32]

In current usage (I just plumbed it in the other day...) color_space is always
non-NULL, but the preceding 2 parameters are optional anyways. So while I agree
it would make more sense to tighten up the API, I don't think it's really worth
doing unless we kept it consistent and tightened up the whole thing, which would
require a decent bit of plumbing/tweaking on the Skia side.

+      if (frame_->format() == VideoFrame::YV12J)

[scherkus (not reviewing), 2014/09/16 00:35:09]

it's a stretch, but one day we might need 16/24-bit YUV JPEG so might as well
create a similar helper function and use a switch so future-rileya@ won't forget
to update all the various code sites

bool IsJPEGColorSpace(...)

[rileya (GONE FROM CHROMIUM), 2014/09/16 00:58:32]

Done.

+        *colorSpace = kJPEG_SkYUVColorSpace;
+      else
+        *colorSpace = kRec601_SkYUVColorSpace;
+    }
+
     for (int plane = VideoFrame::kYPlane; plane <= VideoFrame::kVPlane;
          ++plane) {
       if (sizes) {
         gfx::Size size;
         size = VideoFrame::PlaneSize(
             frame_->format(), plane, frame_->coded_size());
         sizes[plane].set(size.width(), size.height());
       }
       if (row_bytes)
         row_bytes[plane] = frame_->stride(plane);
       if (planes)
         planes[plane] = frame_->data(plane);
     }
     if (planes && row_bytes)
       frame_ = NULL;
     return true;
   }
+
  public:
-
   virtual void set_frame(const scoped_refptr<VideoFrame>& frame) {
     frame_ = frame;
   }
 
  private:
   scoped_refptr<VideoFrame> frame_;
 };
 
 SkCanvasVideoRenderer::SkCanvasVideoRenderer()
-    : generator_(NULL),
-      last_frame_timestamp_(media::kNoTimestamp()) {
+    : generator_(NULL), last_frame_timestamp_(media::kNoTimestamp()) {
   last_frame_.setIsVolatile(true);
 }
 
 SkCanvasVideoRenderer::~SkCanvasVideoRenderer() {}
 
 void SkCanvasVideoRenderer::Paint(const scoped_refptr<VideoFrame>& video_frame,
                                   SkCanvas* canvas,
                                   const gfx::RectF& dest_rect,
                                   uint8 alpha,
                                   SkXfermode::Mode mode,
@@ skipping 60 matching lines @@
                                  SkCanvas* canvas) {
   Paint(video_frame,
         canvas,
         video_frame->visible_rect(),
         0xff,
         SkXfermode::kSrc_Mode,
         media::VIDEO_ROTATION_0);
 }
 
 }  // namespace media