Do YUV conversion on the GPU when copying video frames into a GPU-accelerated canvas.

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 "skia/ext/refptr.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/gpu/SkGr.h"
+#include "third_party/skia/src/gpu/effects/GrYUVtoRGBEffect.h"
 #include "ui/gfx/skbitmap_operations.h"
 
 // Skia internal format depends on a platform. On Android it is ABGR, on others
 // it is ARGB.
 #if SK_B32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_R32_SHIFT == 16 && \
     SK_A32_SHIFT == 24
 #define LIBYUV_I420_TO_ARGB libyuv::I420ToARGB
 #define LIBYUV_I422_TO_ARGB libyuv::I422ToARGB
 #elif SK_R32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_B32_SHIFT == 16 && \
     SK_A32_SHIFT == 24
@@ skipping 152 matching lines @@
 
     default:
       NOTREACHED();
       break;
   }
   bitmap->notifyPixelsChanged();
   bitmap->unlockPixels();
 }
 
 SkCanvasVideoRenderer::SkCanvasVideoRenderer()
-    : last_frame_timestamp_(media::kNoTimestamp()) {
+    : last_frame_timestamp_(media::kNoTimestamp()),
+      yuv_planes_timestamp_(media::kNoTimestamp()) {
 }
 
 SkCanvasVideoRenderer::~SkCanvasVideoRenderer() {}
 
 void SkCanvasVideoRenderer::Paint(media::VideoFrame* video_frame,
                                   SkCanvas* canvas,
                                   const gfx::RectF& dest_rect,
                                   uint8 alpha,
                                   SkXfermode::Mode mode,
                                   VideoRotation video_rotation) {
   if (alpha == 0) {
     return;
   }
 
   SkRect dest;
   dest.set(dest_rect.x(), dest_rect.y(), dest_rect.right(), dest_rect.bottom());
 
   SkPaint paint;
   paint.setAlpha(alpha);
 
   // Paint black rectangle if there isn't a frame available or the
   // frame has an unexpected format.
   if (!video_frame || !IsYUVOrNative(video_frame->format())) {
     canvas->drawRect(dest, paint);
     return;
   }
 
+  // If we have a hardware accelerated canvas, we can try to do YUV conversion
+  // directly from our frame to the output canvas.
+  if (canvas->getGrContext() &&
+      HardwarePaint(
+          video_frame, canvas->getGrContext(), dest, mode, video_rotation)) {
+    // If HardwarePaint() succeeded, then we're all done!
+    return;
+  }
+
   // Check if we should convert and update |last_frame_|.
   if (last_frame_.isNull() ||
       video_frame->timestamp() != last_frame_timestamp_) {
     ConvertVideoFrameToBitmap(video_frame, &last_frame_);
 
     switch (video_rotation) {
       case VIDEO_ROTATION_0:
         break;
       case VIDEO_ROTATION_90:
         last_frame_ = SkBitmapOperations::Rotate(
@@ skipping 22 matching lines @@
 void SkCanvasVideoRenderer::Copy(media::VideoFrame* video_frame,
                                  SkCanvas* canvas) {
   Paint(video_frame,
         canvas,
         video_frame->visible_rect(),
         0xff,
         SkXfermode::kSrc_Mode,
         media::VIDEO_ROTATION_0);
 }
 
+bool SkCanvasVideoRenderer::HardwarePaint(media::VideoFrame* video_frame,
+                                          GrContext* gr,
+                                          const SkRect& dest_rect,
+                                          SkXfermode::Mode mode,
+                                          VideoRotation video_rotation) {
+  if (!IsYUV(video_frame->format()) ||
+      video_frame->format() == VideoFrame::YV12A)
+    return false;
+
+  DCHECK_EQ(video_frame->stride(media::VideoFrame::kUPlane),
+            video_frame->stride(media::VideoFrame::kVPlane));
+
+  // Wrap our planes in SkBitmaps.
+  if (video_frame->timestamp() != yuv_planes_timestamp_) {
+    yuv_planes_[0].installPixels(
+        SkImageInfo::MakeA8(video_frame->coded_size().width(),
+                            video_frame->coded_size().height()),
+        video_frame->data(VideoFrame::kYPlane),
+        video_frame->stride(VideoFrame::kYPlane));
+    yuv_planes_[1].installPixels(
+        SkImageInfo::MakeA8(video_frame->coded_size().width() / 2,
+                            video_frame->coded_size().height() / 2),
+        video_frame->data(VideoFrame::kUPlane),
+        video_frame->stride(VideoFrame::kUPlane));
+    yuv_planes_[2].installPixels(
+        SkImageInfo::MakeA8(video_frame->coded_size().width() / 2,
+                            video_frame->coded_size().height() / 2),
+        video_frame->data(VideoFrame::kVPlane),
+        video_frame->stride(VideoFrame::kVPlane));
+  }
+
+  // Populate GrTextures from the bitmaps. We let Ganesh handle caching here.
+  GrTexture* planes[3];
+  planes[0] = GrLockAndRefCachedBitmapTexture(gr, yuv_planes_[0], NULL);
+  planes[1] = GrLockAndRefCachedBitmapTexture(gr, yuv_planes_[1], NULL);
+  planes[2] = GrLockAndRefCachedBitmapTexture(gr, yuv_planes_[2], NULL);
+
+  skia::RefPtr<GrEffect> effect = skia::AdoptRef<GrEffect>(
+      GrYUVtoRGBEffect::Create(planes[0], planes[1], planes[2]));
+
+  if (!effect)
+    return false;
+
+  SkXfermode::Coeff src, dest;
+  if (!SkXfermode::ModeAsCoeff(mode, &src, &dest))
+    return false;
+
+  GrPaint paint;
+  paint.addColorEffect(effect.get());
+  paint.setBlendFunc(sk_blend_to_grblend(src), sk_blend_to_grblend(dest));
+
+  GrContext::AutoMatrix auto_matrix;
+  auto_matrix.setIdentity(gr, &paint);
+  SkMatrix rotation;
+
+  switch (video_rotation) {
+    case VIDEO_ROTATION_0:
+      rotation.reset();
+      break;
+    case VIDEO_ROTATION_90:
+      rotation.setRotate(90);
+      rotation.postTranslate(video_frame->coded_size().height(), 0);
+      break;
+    case VIDEO_ROTATION_180:
+      rotation.setRotate(180);
+      rotation.postTranslate(video_frame->coded_size().width(),
+                             video_frame->coded_size().height());
+      break;
+    case VIDEO_ROTATION_270:
+      rotation.setRotate(270);
+      rotation.postTranslate(0, video_frame->coded_size().width());
+      break;
+  }
+
+  gr->concatMatrix(rotation);
+  gr->drawRect(paint, dest_rect);
+
+  GrUnlockAndUnrefCachedBitmapTexture(planes[0]);
+  GrUnlockAndUnrefCachedBitmapTexture(planes[1]);
+  GrUnlockAndUnrefCachedBitmapTexture(planes[2]);
+
+  gr->flush();
+
+  yuv_planes_timestamp_ = video_frame->timestamp();
+
+  return true;
+}
+
 }  // namespace media