media: Optimize HW Video to 2D Canvas copy.

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 "gpu/GLES2/gl2extchromium.h"
+#include "gpu/command_buffer/client/gles2_interface.h"
+#include "gpu/command_buffer/common/mailbox_holder.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/GrContext.h"
+#include "third_party/skia/include/gpu/SkGrPixelRef.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
 #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) {
+namespace {
+
+bool IsYUV(media::VideoFrame::Format format) {
   return format == media::VideoFrame::YV12 ||
          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) {
+bool IsYUVOrNative(media::VideoFrame::Format format) {
   return IsYUV(format) || format == media::VideoFrame::NATIVE_TEXTURE;
 }
 
 // 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) {
+void ConvertVideoFrameToBitmap(media::VideoFrame* video_frame,
+                               SkBitmap* bitmap) {
   DCHECK(IsYUVOrNative(video_frame->format()))
       << video_frame->format();
   if (IsYUV(video_frame->format())) {
     DCHECK_EQ(video_frame->stride(media::VideoFrame::kUPlane),
               video_frame->stride(media::VideoFrame::kVPlane));
   }
 
   // Check if |bitmap| needs to be (re)allocated.
   if (bitmap->isNull() ||
       bitmap->width() != video_frame->visible_rect().width() ||
@@ skipping 114 matching lines @@
       break;
 
     default:
       NOTREACHED();
       break;
   }
   bitmap->notifyPixelsChanged();
   bitmap->unlockPixels();
 }
 
+bool EnsureTextureBackedSkBitmap(GrContext* gr,
+                                 SkBitmap* bitmap,
+                                 const gfx::Size& size,
+                                 GrSurfaceOrigin origin,
+                                 GrPixelConfig config) {
+  if (!bitmap->getTexture() || bitmap->width() != size.width() ||
+      bitmap->height() != size.height()) {
+    if (!gr)
+      return false;
+    GrTextureDesc desc;
+    desc.fConfig = config;
+    desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
+    desc.fSampleCnt = 0;
+    desc.fOrigin = origin;
+    desc.fWidth = size.width();
+    desc.fHeight = size.height();
+    skia::RefPtr<GrTexture> texture;
+    texture = skia::AdoptRef(gr->createUncachedTexture(desc, 0, 0));

[Justin Novosad, 2014/08/28 17:23:18]

Using a scratch texture would probably be better for performance

[dshwang, 2014/08/28 17:53:09]

Yep, I'll update.

[dshwang, 2014/09/01 07:54:56]

Done.

+    if (!texture.get())
+      return false;
+
+    SkImageInfo info = SkImageInfo::MakeN32Premul(desc.fWidth, desc.fHeight);
+    SkGrPixelRef* pixelRef = SkNEW_ARGS(SkGrPixelRef, (info, texture.get()));
+    if (!pixelRef)
+      return false;
+    bitmap->setInfo(info);
+    bitmap->setPixelRef(pixelRef)->unref();
+  }
+
+  return true;
+}
+
+bool ConvertVideoFrameToTexture(
+    VideoFrame* video_frame,
+    SkBitmap* bitmap,
+    SkCanvasVideoRenderer::Context3DProvider* context_provider) {
+  DCHECK(context_provider &&
+         video_frame->format() == VideoFrame::NATIVE_TEXTURE);
+  gpu::gles2::GLES2Interface* gl = context_provider->gl;
+  DCHECK(gl);
+
+  // Check if we could reuse existing texture based bitmap.
+  // Otherwise, release existing texture based bitmap and allocate
+  // a new one based on video size.
+  // Use kRGBA_8888_GrPixelConfig, not kSkia8888_GrPixelConfig, because
+  // glCopyTextureChromium doesn't support GL_BGRA_EXT as internal format.
+  if (!EnsureTextureBackedSkBitmap(context_provider->gr_context,
+                                   bitmap,
+                                   video_frame->visible_rect().size(),
+                                   kTopLeft_GrSurfaceOrigin,
+                                   kRGBA_8888_GrPixelConfig)) {
+    return false;
+  }
+
+  unsigned textureId =
+      static_cast<unsigned>((bitmap->getTexture())->getTextureHandle());
+  SkCanvasVideoRenderer::CopyVideoFrameToTexture(
+      gl, video_frame, textureId, 0, GL_RGBA, GL_UNSIGNED_BYTE, true, false);
+  return true;
+}
+
+class SyncPointClientImpl : public VideoFrame::SyncPointClient {
+ public:
+  explicit SyncPointClientImpl(gpu::gles2::GLES2Interface* gl) : gl_(gl) {}
+  virtual ~SyncPointClientImpl() {}
+  virtual uint32 InsertSyncPoint() OVERRIDE {
+    return gl_->InsertSyncPointCHROMIUM();
+  }
+  virtual void WaitSyncPoint(uint32 sync_point) OVERRIDE {
+    gl_->WaitSyncPointCHROMIUM(sync_point);
+  }
+
+ private:
+  gpu::gles2::GLES2Interface* gl_;
+};
+
+}  // anonymous namespace
+
 SkCanvasVideoRenderer::SkCanvasVideoRenderer()
-    : last_frame_timestamp_(media::kNoTimestamp()) {
+    : last_frame_timestamp_(media::kNoTimestamp()),
+      accelerated_last_frame_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) {
+void SkCanvasVideoRenderer::Paint(
+    media::VideoFrame* video_frame,
+    SkCanvas* canvas,
+    const gfx::RectF& dest_rect,
+    uint8 alpha,
+    SkXfermode::Mode mode,
+    VideoRotation video_rotation,
+    SkCanvasVideoRenderer::Context3DProvider* context_provider) {
   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())) {
+  if (!video_frame || video_frame->natural_size().IsEmpty() ||
+      !IsYUVOrNative(video_frame->format())) {
     canvas->drawRect(dest, paint);
     return;
   }
 
+  bool accelerated = false;
+  if (context_provider &&
+      video_frame->format() == media::VideoFrame::NATIVE_TEXTURE &&
+      canvas->getGrContext()) {
+    // TODO(dshwang): Android video decoder doesn't update the timestamp on a
+    // VideoFrame. To reduce redundant copy, Android should update the
+    // timestamp.
+    if (accelerated_last_frame_.isNull() ||
+        video_frame->timestamp() != accelerated_last_frame_timestamp_ ||
+        video_frame->timestamp() == base::TimeDelta()) {
+      accelerated = ConvertVideoFrameToTexture(
+          video_frame, &accelerated_last_frame_, context_provider);
+      if (accelerated) {
+        accelerated_last_frame_timestamp_ = video_frame->timestamp();
+      }
+    } else {
+      DCHECK(accelerated_last_frame_.getTexture());
+      accelerated = true;
+    }
+  }
+
   // Check if we should convert and update |last_frame_|.
-  if (last_frame_.isNull() ||
-      video_frame->timestamp() != last_frame_timestamp_) {
+  if (!accelerated && (last_frame_.isNull() ||

[rileya (GONE FROM CHROMIUM), 2014/08/27 20:30:50]

It doesn't look like we address video rotation in the accelerated case, does
this mean we lose video orientation support for HW decoded frames?

I realize that we don't properly do this for WebGL, but in the accelerated
canvas case I think  we can actually apply the rotation without much fuss...

+                       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(
             last_frame_, SkBitmapOperations::ROTATION_90_CW);
         break;
       case VIDEO_ROTATION_180:
         last_frame_ = SkBitmapOperations::Rotate(
             last_frame_, SkBitmapOperations::ROTATION_180_CW);
         break;
       case VIDEO_ROTATION_270:
         last_frame_ = SkBitmapOperations::Rotate(
             last_frame_, SkBitmapOperations::ROTATION_270_CW);
         break;
     }
 
     last_frame_timestamp_ = video_frame->timestamp();
   }
 
   paint.setXfermodeMode(mode);
 
-  // Paint using |last_frame_|.
-  paint.setFilterLevel(SkPaint::kLow_FilterLevel);
-  canvas->drawBitmapRect(last_frame_, NULL, dest, &paint);
+  canvas->drawBitmapRect(
+      accelerated ? accelerated_last_frame_ : last_frame_, NULL, dest, &paint);
+
+  CleanUpTemporaryBuffers();
 }
 
 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);
+        media::VIDEO_ROTATION_0,
+        NULL);
+}
+
+// If a buffer is not used by 3 sec, remove it.
+void SkCanvasVideoRenderer::CleanUpTemporaryBuffers() {
+  static const base::TimeDelta buffer_time = base::TimeDelta::FromSeconds(3);

[rileya (GONE FROM CHROMIUM), 2014/08/27 20:30:50]

This seems extremely arbitrary. Can you explain the reasoning?

At the very least this might be better as a constant on the SkCanvasRenderer
class itself, along with a comment on why we're using the magic number of 3
seconds.

+  base::TimeDelta last_timestamp =
+      accelerated_last_frame_timestamp_ > last_frame_timestamp_
+          ? accelerated_last_frame_timestamp_
+          : last_frame_timestamp_;
+  if (last_timestamp > last_frame_timestamp_ + buffer_time &&
+      !last_frame_.isNull())
+    last_frame_.reset();
+  if (last_timestamp > accelerated_last_frame_timestamp_ + buffer_time &&
+      !accelerated_last_frame_.isNull())
+    accelerated_last_frame_.reset();
+}
+
+// static
+void SkCanvasVideoRenderer::CopyVideoFrameToTexture(

[rileya (GONE FROM CHROMIUM), 2014/08/27 20:30:50]

I'm not sure how I feel about putting all of this GL stuff tacked onto
SkCanvasVideoRenderer, this seems like something Blink should be able to do.
That said, this may be a necessary evil, I've recently been looking at the SW
video->WebGL case and my current solution also requires some similar ugliness...
(https://codereview.chromium.org/513593003/ for reference)

+    gpu::gles2::GLES2Interface* gl,
+    VideoFrame* video_frame,
+    unsigned int texture,
+    unsigned int level,
+    unsigned int internal_format,
+    unsigned int type,
+    bool premultiply_alpha,
+    bool flip_y) {
+  DCHECK(video_frame && video_frame->format() == VideoFrame::NATIVE_TEXTURE);
+  const gpu::MailboxHolder* mailbox_holder = video_frame->mailbox_holder();
+  DCHECK(mailbox_holder->texture_target == GL_TEXTURE_2D ||
+         mailbox_holder->texture_target == GL_TEXTURE_EXTERNAL_OES);
+
+  gl->WaitSyncPointCHROMIUM(mailbox_holder->sync_point);
+  uint32 source_texture = gl->CreateAndConsumeTextureCHROMIUM(
+      mailbox_holder->texture_target, mailbox_holder->mailbox.name);
+
+  // The video is stored in a unmultiplied format, so premultiply
+  // if necessary.
+  gl->PixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM, premultiply_alpha);
+  // Application itself needs to take care of setting the right flip_y
+  // value down to get the expected result.
+  // flip_y==true means to reverse the video orientation while
+  // flip_y==false means to keep the intrinsic orientation.
+  gl->PixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, flip_y);
+  gl->CopyTextureCHROMIUM(
+      GL_TEXTURE_2D, source_texture, texture, level, internal_format, type);
+  gl->PixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, false);
+  gl->PixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM, false);
+
+  gl->DeleteTextures(1, &source_texture);
+  gl->Flush();
+
+  SyncPointClientImpl client(gl);
+  video_frame->UpdateReleaseSyncPoint(&client);
 }
 
 }  // namespace media