Support reading pixels from HW-decoded video textures into canvas/webgl.

webkit/media/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 "webkit/media/skcanvas_video_renderer.h"
 
 #include "base/logging.h"
 #include "media/base/video_frame.h"
 #include "media/base/yuv_convert.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 
 namespace webkit_media {
 
+static bool IsEitherYV12OrYV16(media::VideoFrame::Format format) {
+  return format == media::VideoFrame::YV12 || format == media::VideoFrame::YV16;
+}
+
+static bool IsEitherYV12OrYV16OrNative(media::VideoFrame::Format format) {
+  return IsEitherYV12OrYV16(format) ||
+    format == media::VideoFrame::NATIVE_TEXTURE;

[scherkus (not reviewing), 2012/10/01 18:15:04]

indent

[Ami GONE FROM CHROMIUM, 2012/10/01 18:40:26]

Done.

+}
+
 // CanFastPaint is a helper method to determine the conditions for fast
 // painting. The conditions are:
 // 1. No skew in canvas matrix.
 // 2. No flipping nor mirroring.
 // 3. Canvas has pixel format ARGB8888.
 // 4. Canvas is opaque.
+// 5. Frame format is YV12 or YV16.
 //
 // TODO(hclam): The fast paint method should support flipping and mirroring.
 // Disable the flipping and mirroring checks once we have it.
 static bool CanFastPaint(SkCanvas* canvas, const gfx::Rect& dest_rect,
-                         uint8_t alpha) {
-  if (alpha != 0xFF) {
+                         uint8_t alpha, media::VideoFrame::Format format) {
+  if (alpha != 0xFF || !IsEitherYV12OrYV16(format))
     return false;
-  }
 
   const SkMatrix& total_matrix = canvas->getTotalMatrix();
   // Perform the following checks here:
   // 1. Check for skewing factors of the transformation matrix. They should be
   //    zero.
   // 2. Check for mirroring and flipping. Make sure they are greater than zero.
   if (SkScalarNearlyZero(total_matrix.getSkewX()) &&
       SkScalarNearlyZero(total_matrix.getSkewY()) &&
       total_matrix.getScaleX() > 0 &&
       total_matrix.getScaleY() > 0) {
     SkDevice* device = canvas->getDevice();
     const SkBitmap::Config config = device->config();
 
     if (config == SkBitmap::kARGB_8888_Config && device->isOpaque()) {
       return true;
     }
   }
 
   return false;
 }
 
-static bool IsEitherYV12OrYV16(media::VideoFrame::Format format) {
-  return format == media::VideoFrame::YV12 || format == media::VideoFrame::YV16;
-}
-
 // Fast paint does YUV => RGB, scaling, blitting all in one step into the
 // canvas. It's not always safe and appropriate to perform fast paint.
 // CanFastPaint() is used to determine the conditions.
 static void FastPaint(
     const scoped_refptr<media::VideoFrame>& video_frame,
     SkCanvas* canvas,
     const gfx::Rect& dest_rect) {
   DCHECK(IsEitherYV12OrYV16(video_frame->format())) << video_frame->format();
   DCHECK_EQ(video_frame->stride(media::VideoFrame::kUPlane),
             video_frame->stride(media::VideoFrame::kVPlane));
@@ skipping 94 matching lines @@
                          media::FILTER_BILINEAR);
   bitmap.unlockPixels();
 }
 
 // Converts a VideoFrame containing YUV data to a SkBitmap containing RGB data.
 //
 // |bitmap| will be (re)allocated to match the dimensions of |video_frame|.
 static void ConvertVideoFrameToBitmap(
     const scoped_refptr<media::VideoFrame>& video_frame,
     SkBitmap* bitmap) {
-  DCHECK(IsEitherYV12OrYV16(video_frame->format())) << video_frame->format();
-  DCHECK(video_frame->stride(media::VideoFrame::kUPlane) ==
-         video_frame->stride(media::VideoFrame::kVPlane));
+  DCHECK(IsEitherYV12OrYV16OrNative(video_frame->format()))
+      << video_frame->format();
+  if (IsEitherYV12OrYV16(video_frame->format())) {
+    DCHECK(video_frame->stride(media::VideoFrame::kUPlane) ==

[scherkus (not reviewing), 2012/10/01 18:15:04]

no _EQ love?

[Ami GONE FROM CHROMIUM, 2012/10/01 18:40:26]

Done.

+           video_frame->stride(media::VideoFrame::kVPlane));
+  }
 
   // Check if |bitmap| needs to be (re)allocated.
   if (bitmap->isNull() ||
       bitmap->width() != video_frame->data_size().width() ||
       bitmap->height() != video_frame->data_size().height()) {
     bitmap->setConfig(SkBitmap::kARGB_8888_Config,
                       video_frame->data_size().width(),
                       video_frame->data_size().height());
     bitmap->allocPixels();
     bitmap->setIsVolatile(true);
   }
 
   bitmap->lockPixels();
-  media::YUVType yuv_type =
+  if (IsEitherYV12OrYV16(video_frame->format())) {
+    media::YUVType yuv_type =
       (video_frame->format() == media::VideoFrame::YV12) ?

[scherkus (not reviewing), 2012/10/01 18:15:04]

fix indent

[Ami GONE FROM CHROMIUM, 2012/10/01 18:40:26]

Done.

       media::YV12 : media::YV16;
-  media::ConvertYUVToRGB32(video_frame->data(media::VideoFrame::kYPlane),
-                           video_frame->data(media::VideoFrame::kUPlane),
-                           video_frame->data(media::VideoFrame::kVPlane),
-                           static_cast<uint8*>(bitmap->getPixels()),
-                           video_frame->data_size().width(),
-                           video_frame->data_size().height(),
-                           video_frame->stride(media::VideoFrame::kYPlane),
-                           video_frame->stride(media::VideoFrame::kUPlane),
-                           bitmap->rowBytes(),
-                           yuv_type);
+    media::ConvertYUVToRGB32(video_frame->data(media::VideoFrame::kYPlane),
+                             video_frame->data(media::VideoFrame::kUPlane),
+                             video_frame->data(media::VideoFrame::kVPlane),
+                             static_cast<uint8*>(bitmap->getPixels()),
+                             video_frame->data_size().width(),
+                             video_frame->data_size().height(),
+                             video_frame->stride(media::VideoFrame::kYPlane),
+                             video_frame->stride(media::VideoFrame::kUPlane),
+                             bitmap->rowBytes(),
+                             yuv_type);
+  } else {
+    DCHECK_EQ(video_frame->format(), media::VideoFrame::NATIVE_TEXTURE);
+    video_frame->ReadPixelsFromNativeTexture(bitmap->getPixels());
+  }
   bitmap->notifyPixelsChanged();
   bitmap->unlockPixels();
 }
 
 SkCanvasVideoRenderer::SkCanvasVideoRenderer()
     : last_frame_timestamp_(media::kNoTimestamp()) {
 }
 
 SkCanvasVideoRenderer::~SkCanvasVideoRenderer() {}
 
 void SkCanvasVideoRenderer::Paint(media::VideoFrame* video_frame,
                                   SkCanvas* canvas,
                                   const gfx::Rect& dest_rect,
                                   uint8_t alpha) {
   if (alpha == 0) {
     return;
   }
 
   SkRect dest;
   dest.set(SkIntToScalar(dest_rect.x()), SkIntToScalar(dest_rect.y()),
            SkIntToScalar(dest_rect.right()), SkIntToScalar(dest_rect.bottom()));
 
   SkPaint paint;
   paint.setAlpha(alpha);
 
-  // Paint black rectangle if there isn't a frame available or if the format is
-  // unexpected (can happen e.g. when normally painting to HW textures but
-  // during shutdown path).
-  if (!video_frame || !IsEitherYV12OrYV16(video_frame->format())) {
+  // Paint black rectangle if there isn't a frame available or the
+  // frame has an unexpected format.
+  if (!video_frame || !IsEitherYV12OrYV16OrNative(video_frame->format())) {
     canvas->drawRect(dest, paint);
     return;
   }
 
   // Scale and convert to RGB in one step if we can.
-  if (CanFastPaint(canvas, dest_rect, alpha)) {
+  if (CanFastPaint(canvas, dest_rect, alpha, video_frame->format())) {
     FastPaint(video_frame, canvas, dest_rect);
     return;
   }
 
   // Check if we should convert and update |last_frame_|.
   if (last_frame_.isNull() ||
       video_frame->GetTimestamp() != last_frame_timestamp_) {
     ConvertVideoFrameToBitmap(video_frame, &last_frame_);
     last_frame_timestamp_ = video_frame->GetTimestamp();
   }
 
   // Do a slower paint using |last_frame_|.
   paint.setFilterBitmap(true);
   canvas->drawBitmapRect(last_frame_, NULL, dest, &paint);
 }
 
 }  // namespace webkit_media