webgl: optimize webgl.texSubImage2D(video) path.

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 "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"
@@ skipping 143 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);
+        gl, video_frame,
+        SkCanvasVideoRenderer::CopyFrameSingleTextureParams(
+            SkCanvasVideoRenderer::CopyFrameSingleTextureParams::FullCopy,
+            GL_TEXTURE_2D, source_texture, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0, 0,
+            true, false));
   } else {
     gl->WaitSyncPointCHROMIUM(mailbox_holder.sync_point);
     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 353 matching lines @@
     case PIXEL_FORMAT_MT21:
     case PIXEL_FORMAT_UNKNOWN:
       NOTREACHED();
   }
 }
 
 // static
 void SkCanvasVideoRenderer::CopyVideoFrameSingleTextureToGLTexture(
     gpu::gles2::GLES2Interface* gl,
     VideoFrame* video_frame,
-    unsigned int texture,
-    unsigned int internal_format,
-    unsigned int type,
-    bool premultiply_alpha,
-    bool flip_y) {
+    const CopyFrameSingleTextureParams& params) {
   DCHECK(video_frame);
   DCHECK(video_frame->HasTextures());
   DCHECK_EQ(1u, VideoFrame::NumPlanes(video_frame->format()));
 
   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;
 
   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.
   // 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(GL_TEXTURE_2D, source_texture, texture,
-                          internal_format, type, flip_y, premultiply_alpha,
-                          false);
+  if (params.copy_type == CopyFrameSingleTextureParams::FullCopy) {
+    DCHECK(!params.xoffset && !params.yoffset);
+    gl->CopyTextureCHROMIUM(params.target, source_texture, params.texture,
+                            params.internal_format, params.type, params.flip_y,
+                            params.premultiply_alpha, false);
+  } else {
+    DCHECK_EQ(static_cast<unsigned int>(GL_FALSE), params.internal_format);
+    DCHECK_EQ(static_cast<unsigned int>(GL_FALSE), params.type);
+    gl->CopySubTextureCHROMIUM(params.target, source_texture, params.texture,
+                               params.xoffset, params.yoffset, 0, 0,
+                               video_frame->natural_size().width(),
+                               video_frame->natural_size().height(),
+                               params.flip_y, params.premultiply_alpha, false);
+  }
 
   gl->DeleteTextures(1, &source_texture);
   gl->Flush();
 
   SyncPointClientImpl client(gl);
   video_frame->UpdateReleaseSyncPoint(&client);
 }
 
 void SkCanvasVideoRenderer::ResetCache() {
   // Clear cached values.
   last_image_ = nullptr;
   last_timestamp_ = kNoTimestamp();
 }
 
+SkCanvasVideoRenderer::CopyFrameSingleTextureParams::
+    CopyFrameSingleTextureParams(CopyType copy_type,
+                                 unsigned target,
+                                 unsigned texture,
+                                 unsigned internal_format,
+                                 unsigned type,
+                                 int level,
+                                 int xoffset,
+                                 int yoffset,
+                                 bool premultiply_alpha,
+                                 bool flip_y)
+    : copy_type(copy_type),
+      target(target),
+      texture(texture),
+      internal_format(internal_format),
+      type(type),
+      level(level),
+      xoffset(xoffset),
+      yoffset(yoffset),
+      premultiply_alpha(premultiply_alpha),
+      flip_y(flip_y) {}
+
 }  // namespace media