Optimize webgl texImage2D from YUV video textures.

media/renderers/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/renderers/skcanvas_video_renderer.h"
 
 #include <limits>
 
 #include "base/macros.h"
 #include "gpu/GLES2/gl2extchromium.h"
@@ skipping 164 matching lines @@
 
   gpu::gles2::GLES2Interface* gl = context_3d.gl;
   unsigned source_texture = 0;
   if (mailbox_holder.texture_target != GL_TEXTURE_2D) {
     // TODO(dcastagna): At the moment Skia doesn't support targets different
     // than GL_TEXTURE_2D.  Avoid this copy once
     // https://code.google.com/p/skia/issues/detail?id=3868 is addressed.
     gl->GenTextures(1, &source_texture);
     DCHECK(source_texture);
     gl->BindTexture(GL_TEXTURE_2D, source_texture);
-    SkCanvasVideoRenderer::CopyVideoFrameSingleTextureToGLTexture(
-        gl, video_frame, source_texture, GL_RGBA, GL_UNSIGNED_BYTE, true,
-        false);
+    SkCanvasVideoRenderer::CopyVideoFrameTexturesToGLTexture(
+        context_3d, gl, video_frame, source_texture, GL_RGBA, GL_UNSIGNED_BYTE,
+        true, false);
   } else {
     gl->WaitSyncTokenCHROMIUM(mailbox_holder.sync_token.GetConstData());
     source_texture = gl->CreateAndConsumeTextureCHROMIUM(
         mailbox_holder.texture_target, mailbox_holder.mailbox.name);
   }
   GrBackendTextureDesc desc;
   desc.fFlags = kRenderTarget_GrBackendTextureFlag;
   desc.fOrigin = kTopLeft_GrSurfaceOrigin;
   desc.fWidth = video_frame->coded_size().width();
   desc.fHeight = video_frame->coded_size().height();
@@ skipping 437 matching lines @@
     case PIXEL_FORMAT_RGB24:
     case PIXEL_FORMAT_RGB32:
     case PIXEL_FORMAT_MJPEG:
     case PIXEL_FORMAT_MT21:
     case PIXEL_FORMAT_UNKNOWN:
       NOTREACHED();
   }
 }
 
 // static
-void SkCanvasVideoRenderer::CopyVideoFrameSingleTextureToGLTexture(
-    gpu::gles2::GLES2Interface* gl,
+bool SkCanvasVideoRenderer::CopyVideoFrameTexturesToGLTexture(
+    const Context3D& context_3d,
+    gpu::gles2::GLES2Interface* destination_gl,
     VideoFrame* video_frame,
     unsigned int texture,
     unsigned int internal_format,
     unsigned int type,
     bool premultiply_alpha,
     bool flip_y) {
   DCHECK(video_frame);
   DCHECK(video_frame->HasTextures());
+  if (media::VideoFrame::NumPlanes(video_frame->format()) > 1) {
+    if (!context_3d.gr_context)
+      return false;
+    sk_sp<SkImage> image =
+        NewSkImageFromVideoFrameYUVTextures(video_frame, context_3d);
 
-  const gpu::MailboxHolder& mailbox_holder = video_frame->mailbox_holder(0);
-  DCHECK(mailbox_holder.texture_target == GL_TEXTURE_2D ||
-         mailbox_holder.texture_target == GL_TEXTURE_RECTANGLE_ARB ||
-         mailbox_holder.texture_target == GL_TEXTURE_EXTERNAL_OES)
-      << mailbox_holder.texture_target;
+    const GrGLTextureInfo* texture_info =
+        skia::GrBackendObjectToGrGLTextureInfo(image->getTextureHandle(true));
 
-  gl->WaitSyncTokenCHROMIUM(mailbox_holder.sync_token.GetConstData());
-  uint32_t source_texture = gl->CreateAndConsumeTextureCHROMIUM(
-      mailbox_holder.texture_target, mailbox_holder.mailbox.name);
+    gpu::gles2::GLES2Interface* canvas_gl = context_3d.gl;
+    gpu::MailboxHolder mailbox_holder;
+    mailbox_holder.texture_target = texture_info->fTarget;
+    canvas_gl->GenMailboxCHROMIUM(mailbox_holder.mailbox.name);
+    canvas_gl->ProduceTextureDirectCHROMIUM(texture_info->fID,

[Daniele Castagna, 2016/07/11 18:23:36]

Isn't this assuming that SkImage has only one texture? Right now we copy the
three YUV texture into one when we create it, but in the future Skia might keep
references to the three textures until it draws.

+                                            mailbox_holder.texture_target,
+                                            mailbox_holder.mailbox.name);
 
-  // The video is stored in a unmultiplied format, so premultiply
-  // if necessary.
-  // 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->CopyTextureCHROMIUM(source_texture, texture, internal_format, type,
-                          flip_y, premultiply_alpha, false);
-  gl->DeleteTextures(1, &source_texture);
-  gl->Flush();
+    // Wait for mailbox creation on canvas context before consuming it and
+    // copying from it on the consumer context.
+    const GLuint64 fence_sync = canvas_gl->InsertFenceSyncCHROMIUM();
+    canvas_gl->ShallowFlushCHROMIUM();
+    canvas_gl->GenSyncTokenCHROMIUM(fence_sync,
+                                    mailbox_holder.sync_token.GetData());
 
-  SyncTokenClientImpl client(gl);
-  video_frame->UpdateReleaseSyncToken(&client);
+    destination_gl->WaitSyncTokenCHROMIUM(
+        mailbox_holder.sync_token.GetConstData());
+    uint32_t source_texture2 = destination_gl->CreateAndConsumeTextureCHROMIUM(
+        mailbox_holder.texture_target, mailbox_holder.mailbox.name);
+
+    destination_gl->CopyTextureCHROMIUM(source_texture2, texture,

[Daniele Castagna, 2016/07/11 18:23:36]

We're not validating internal_format anywhere if num_planes > 1. Should we?

+                                        internal_format, type, flip_y,
+                                        premultiply_alpha, false);
+    destination_gl->DeleteTextures(1, &source_texture2);
+
+    // Wait for copy to complete before source texture destruction.
+    const GLuint64 dest_fence_sync = destination_gl->InsertFenceSyncCHROMIUM();
+    destination_gl->ShallowFlushCHROMIUM();
+    gpu::SyncToken dest_sync_token;
+    destination_gl->GenSyncTokenCHROMIUM(dest_fence_sync,
+                                         dest_sync_token.GetData());
+    canvas_gl->WaitSyncTokenCHROMIUM(dest_sync_token.GetConstData());
+
+    SyncTokenClientImpl client(canvas_gl);
+    video_frame->UpdateReleaseSyncToken(&client);
+  } else {
+    const gpu::MailboxHolder& mailbox_holder = video_frame->mailbox_holder(0);
+    DCHECK(mailbox_holder.texture_target == GL_TEXTURE_2D ||
+           mailbox_holder.texture_target == GL_TEXTURE_RECTANGLE_ARB ||
+           mailbox_holder.texture_target == GL_TEXTURE_EXTERNAL_OES)
+        << mailbox_holder.texture_target;
+
+    destination_gl->WaitSyncTokenCHROMIUM(
+        mailbox_holder.sync_token.GetConstData());
+    uint32_t source_texture = destination_gl->CreateAndConsumeTextureCHROMIUM(
+        mailbox_holder.texture_target, mailbox_holder.mailbox.name);
+
+    // The video is stored in a unmultiplied format, so premultiply
+    // if necessary.
+    // 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.
+    destination_gl->CopyTextureCHROMIUM(source_texture, texture,
+                                        internal_format, type, flip_y,
+                                        premultiply_alpha, false);
+    destination_gl->DeleteTextures(1, &source_texture);
+    destination_gl->Flush();
+
+    SyncTokenClientImpl client(destination_gl);
+    video_frame->UpdateReleaseSyncToken(&client);
+  }
+
+  return true;
 }
 
 void SkCanvasVideoRenderer::ResetCache() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Clear cached values.
   last_image_ = nullptr;
   last_timestamp_ = kNoTimestamp();
 }
 
 }  // namespace media