Support uploads of sub-rectangles of canvases to 2D and 3D textures.

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 4549 matching lines @@
   // it later and recalculate it based on the Image whose data we'll
   // upload. It's important that there be no possible differences in
   // the logic which computes the image's size.
   return IntRect(0, 0, -1, -1);
 }
 
 IntRect WebGLRenderingContextBase::safeGetImageSize(Image* image) {
   if (!image)
     return IntRect();
 
-  return IntRect(0, 0, image->width(), image->height());
+  return getTextureSourceSize(image);
 }
 
 IntRect WebGLRenderingContextBase::getImageDataSize(ImageData* pixels) {
   DCHECK(pixels);
-  return IntRect(0, 0, pixels->width(), pixels->height());
+  return getTextureSourceSize(pixels);
 }
 
 void WebGLRenderingContextBase::texImageHelperDOMArrayBufferView(
     TexImageFunctionID functionID,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
@@ skipping 222 matching lines @@
     return;
   if (!validateTexImageBinding(funcName, functionID, target))
     return;
 
   RefPtr<Image> imageForRender = image->cachedImage()->getImage();
   if (imageForRender && imageForRender->isSVGImage())
     imageForRender = drawImageIntoBuffer(
         imageForRender.release(), image->width(), image->height(), funcName);
 
   TexImageFunctionType functionType;
-  if (functionID == TexImage2D)
+  if (functionID == TexImage2D || functionID == TexImage3D)
     functionType = TexImage;
   else
     functionType = TexSubImage;
   if (!imageForRender ||
       !validateTexFunc(funcName, functionType, SourceHTMLImageElement, target,
                        level, internalformat, imageForRender->width(),
                        imageForRender->height(), depth, 0, format, type,
                        xoffset, yoffset, zoffset))
     return;
 
@@ skipping 27 matching lines @@
   // TODO(crbug.com/622958): Implement GPU-to-GPU path for WebGL 2 and more
   // internal formats.
   if (functionID == TexSubImage2D &&
       (isWebGL2OrHigher() || extensionEnabled(OESTextureFloatName) ||
        extensionEnabled(OESTextureHalfFloatName) ||
        extensionEnabled(EXTsRGBName)))
     return false;
   return true;
 }
 
-void WebGLRenderingContextBase::texImageCanvasByGPU(HTMLCanvasElement* canvas,
-                                                    GLuint targetTexture,
-                                                    GLenum targetInternalformat,
-                                                    GLenum targetType,
-                                                    GLint targetLevel) {
+void WebGLRenderingContextBase::texImageCanvasByGPU(
+    HTMLCanvasElement* canvas,
+    GLuint targetTexture,
+    GLenum targetInternalformat,
+    GLenum targetType,
+    GLint targetLevel,
+    GLint xoffset,
+    GLint yoffset,
+    const IntRect& sourceSubRectangle) {
   if (!canvas->is3D()) {
     ImageBuffer* buffer = canvas->buffer();
     if (buffer &&
         !buffer->copyToPlatformTexture(
             contextGL(), targetTexture, targetInternalformat, targetType,
-            targetLevel, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
+            targetLevel, m_unpackPremultiplyAlpha, m_unpackFlipY,
+            IntPoint(xoffset, yoffset), sourceSubRectangle)) {
       NOTREACHED();
     }
   } else {
     WebGLRenderingContextBase* gl =
         toWebGLRenderingContextBase(canvas->renderingContext());
     ScopedTexture2DRestorer restorer(gl);
     if (!gl->drawingBuffer()->copyToPlatformTexture(
             contextGL(), targetTexture, targetInternalformat, targetType,
             targetLevel, m_unpackPremultiplyAlpha, !m_unpackFlipY,
-            BackBuffer)) {
+            IntPoint(xoffset, yoffset), sourceSubRectangle, BackBuffer)) {
       NOTREACHED();
     }
   }
 }
 
-void WebGLRenderingContextBase::texImageByGPU(TexImageByGPUType functionType,
-                                              WebGLTexture* texture,
-                                              GLenum target,
-                                              GLint level,
-                                              GLint internalformat,
-                                              GLenum type,
-                                              GLint xoffset,
-                                              GLint yoffset,
-                                              GLint zoffset,
-                                              CanvasImageSource* image) {
+void WebGLRenderingContextBase::texImageByGPU(
+    TexImageByGPUType functionType,
+    WebGLTexture* texture,
+    GLenum target,
+    GLint level,
+    GLint internalformat,
+    GLenum type,
+    GLint xoffset,
+    GLint yoffset,
+    GLint zoffset,
+    CanvasImageSource* image,
+    const IntRect& sourceSubRectangle) {
   DCHECK(image->isCanvasElement() || image->isImageBitmap());
-  int width = image->sourceWidth();
-  int height = image->sourceHeight();
+  int width = sourceSubRectangle.width();
+  int height = sourceSubRectangle.height();
 
   ScopedTexture2DRestorer restorer(this);
 
   GLuint targetTexture = texture->object();
   GLenum targetType = type;
   GLenum targetInternalformat = internalformat;
   GLint targetLevel = level;
   bool possibleDirectCopy = false;
   if (functionType == TexImage2DByGPU) {
     possibleDirectCopy = Extensions3DUtil::canUseCopyTextureCHROMIUM(
         target, internalformat, type, level);
   }
 
+  GLint copyXOffset = xoffset;
+  GLint copyYOffset = yoffset;
+
   // if direct copy is not possible, create a temporary texture and then copy
   // from canvas to temporary texture to target texture.
   if (!possibleDirectCopy) {
     targetLevel = 0;
     targetInternalformat = GL_RGBA;
     targetType = GL_UNSIGNED_BYTE;
     contextGL()->GenTextures(1, &targetTexture);
     contextGL()->BindTexture(GL_TEXTURE_2D, targetTexture);
     contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
                                GL_NEAREST);
     contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                                GL_NEAREST);
     contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
                                GL_CLAMP_TO_EDGE);
     contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
                                GL_CLAMP_TO_EDGE);
     contextGL()->TexImage2D(GL_TEXTURE_2D, 0, targetInternalformat, width,
                             height, 0, GL_RGBA, targetType, 0);
+    copyXOffset = 0;
+    copyYOffset = 0;
   }
 
-  if (image->isCanvasElement())
+  if (image->isCanvasElement()) {
     texImageCanvasByGPU(static_cast<HTMLCanvasElement*>(image), targetTexture,
-                        targetInternalformat, targetType, targetLevel);
-  else
+                        targetInternalformat, targetType, targetLevel,
+                        copyXOffset, copyYOffset, sourceSubRectangle);
+  } else {
     texImageBitmapByGPU(static_cast<ImageBitmap*>(image), targetTexture,
                         targetInternalformat, targetType, targetLevel,
                         !m_unpackFlipY);
+  }
 
   if (!possibleDirectCopy) {
     GLuint tmpFBO;
     contextGL()->GenFramebuffers(1, &tmpFBO);
     contextGL()->BindFramebuffer(GL_FRAMEBUFFER, tmpFBO);
     contextGL()->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                       GL_TEXTURE_2D, targetTexture, 0);
     contextGL()->BindTexture(texture->getTarget(), texture->object());
     if (functionType == TexImage2DByGPU) {
       contextGL()->CopyTexSubImage2D(target, level, 0, 0, 0, 0, width, height);
@@ skipping 16 matching lines @@
     TexImageFunctionID functionID,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLenum format,
     GLenum type,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     HTMLCanvasElement* canvas,
+    const IntRect& sourceSubRectangle,
+    GLsizei depth,
+    GLint unpackImageHeight,
     ExceptionState& exceptionState) {
   const char* funcName = getTexImageFunctionName(functionID);
   if (isContextLost())
     return;
   if (!validateHTMLCanvasElement(funcName, canvas, exceptionState))
     return;
   WebGLTexture* texture = validateTexImageBinding(funcName, functionID, target);
   if (!texture)
     return;
   TexImageFunctionType functionType;
   if (functionID == TexImage2D)
     functionType = TexImage;
   else
     functionType = TexSubImage;
   if (!validateTexFunc(funcName, functionType, SourceHTMLCanvasElement, target,
                        level, internalformat, canvas->width(), canvas->height(),
-                       1, 0, format, type, xoffset, yoffset, zoffset))
+                       depth, 0, format, type, xoffset, yoffset, zoffset))
     return;
+
+  // Note that the sub-rectangle validation is needed for the GPU-GPU
+  // copy case, but is redundant for the software upload case
+  // (texImageImpl).
+  bool selectingSubRectangle = false;
+  if (!validateTexImageSubRectangle(
+          funcName, functionID, canvas, sourceSubRectangle, depth,
+          unpackImageHeight, &selectingSubRectangle)) {
+    return;
+  }
+
+  if (functionID == TexImage3D || functionID == TexSubImage3D) {
+    DCHECK_GE(unpackImageHeight, 0);
+
+    // Verify that the image data can cover the required depth.
+    CheckedNumeric<GLint> maxDepthSupported = 1;
+    if (unpackImageHeight) {
+      maxDepthSupported = sourceSubRectangle.height();
+      maxDepthSupported /= unpackImageHeight;
+    }
+
+    if (!maxDepthSupported.IsValid() ||
+        maxDepthSupported.ValueOrDie() < depth) {
+      synthesizeGLError(
+          GL_INVALID_OPERATION, funcName,
+          "Not enough data supplied to upload to a 3D texture with depth > 1");
+      return;
+    }
+  } else {
+    DCHECK_EQ(depth, 1);
+    DCHECK_EQ(unpackImageHeight, 0);
+  }
+
   if (functionID == TexImage2D || functionID == TexSubImage2D) {
     // texImageByGPU relies on copyTextureCHROMIUM which doesn't support
     // float/integer/sRGB internal format.
     // TODO(crbug.com/622958): relax the constrains if copyTextureCHROMIUM is
     // upgraded to handle more formats.
     if (!canvas->renderingContext() ||
         !canvas->renderingContext()->isAccelerated() ||
         !canUseTexImageByGPU(functionID, internalformat, type)) {
       // 2D canvas has only FrontBuffer.
       texImageImpl(functionID, target, level, internalformat, xoffset, yoffset,
                    zoffset, format, type,
                    canvas->copiedImage(FrontBuffer, PreferAcceleration).get(),
                    WebGLImageConversion::HtmlDomCanvas, m_unpackFlipY,
-                   m_unpackPremultiplyAlpha,
-                   IntRect(0, 0, canvas->width(), canvas->height()), 1, 0);
+                   m_unpackPremultiplyAlpha, sourceSubRectangle, 1, 0);
       return;
     }
 
+    // The GPU-GPU copy path uses the Y-up coordinate system.
+    IntRect adjustedSourceSubRectangle = sourceSubRectangle;
+    if (!m_unpackFlipY) {
+      adjustedSourceSubRectangle.setY(canvas->height() -
+                                      adjustedSourceSubRectangle.maxY());
+    }
+
     if (functionID == TexImage2D) {
-      texImage2DBase(target, level, internalformat, canvas->width(),
-                     canvas->height(), 0, format, type, 0);
+      texImage2DBase(target, level, internalformat, sourceSubRectangle.width(),
+                     sourceSubRectangle.height(), 0, format, type, 0);
       texImageByGPU(TexImage2DByGPU, texture, target, level, internalformat,
-                    type, 0, 0, 0, canvas);
+                    type, 0, 0, 0, canvas, adjustedSourceSubRectangle);
     } else {
       texImageByGPU(TexSubImage2DByGPU, texture, target, level, GL_RGBA, type,
-                    xoffset, yoffset, 0, canvas);
+                    xoffset, yoffset, 0, canvas, adjustedSourceSubRectangle);
     }
   } else {
-    DCHECK_EQ(functionID, TexSubImage3D);
-    // FIXME: Implement GPU-to-GPU copy path (crbug.com/586269).
-    texImageImpl(TexSubImage3D, target, level, 0, xoffset, yoffset, zoffset,
-                 format, type,
+    // 3D functions.
+
+    // TODO(zmo): Implement GPU-to-GPU copy path (crbug.com/612542).
+    // Note that code will also be needed to copy to layers of 3D
+    // textures, and elements of 2D texture arrays.
+    texImageImpl(functionID, target, level, internalformat, xoffset, yoffset,
+                 zoffset, format, type,
                  canvas->copiedImage(FrontBuffer, PreferAcceleration).get(),
                  WebGLImageConversion::HtmlDomCanvas, m_unpackFlipY,
-                 m_unpackPremultiplyAlpha,
-                 IntRect(0, 0, canvas->width(), canvas->height()), 1, 0);
+                 m_unpackPremultiplyAlpha, sourceSubRectangle, depth,
+                 unpackImageHeight);
   }
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target,
                                            GLint level,
                                            GLint internalformat,
                                            GLenum format,
                                            GLenum type,
                                            HTMLCanvasElement* canvas,
                                            ExceptionState& exceptionState) {
-  texImageHelperHTMLCanvasElement(TexImage2D, target, level, internalformat,
-                                  format, type, 0, 0, 0, canvas,
-                                  exceptionState);
+  texImageHelperHTMLCanvasElement(
+      TexImage2D, target, level, internalformat, format, type, 0, 0, 0, canvas,
+      getTextureSourceSize(canvas), 1, 0, exceptionState);
 }
 
 PassRefPtr<Image> WebGLRenderingContextBase::videoFrameToImage(
     HTMLVideoElement* video) {
   IntSize size(video->videoWidth(), video->videoHeight());
   ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);
   if (!buf) {
     synthesizeGLError(GL_OUT_OF_MEMORY, "texImage2D", "out of memory");
     return nullptr;
   }
@@ skipping 60 matching lines @@
           // WebMediaPlayer implementation to do any necessary color space
           // conversion on the GPU (though it
           // may still do a CPU conversion and upload the results).
           video->paintCurrentFrame(
               imageBuffer->canvas(),
               IntRect(0, 0, video->videoWidth(), video->videoHeight()),
               nullptr);
 
           // This is a straight GPU-GPU copy, any necessary color space
           // conversion was handled in the paintCurrentFrameInContext() call.
+
+          // Note that copyToPlatformTexture no longer allocates the
+          // destination texture.
+          texImage2DBase(target, level, internalformat, video->videoWidth(),
+                         video->videoHeight(), 0, format, type, nullptr);
+
           if (imageBuffer->copyToPlatformTexture(
                   contextGL(), texture->object(), internalformat, type, level,
-                  m_unpackPremultiplyAlpha, m_unpackFlipY)) {
+                  m_unpackPremultiplyAlpha, m_unpackFlipY, IntPoint(0, 0),
+                  IntRect(0, 0, video->videoWidth(), video->videoHeight()))) {
             return;
           }
         }
       }
     }
   }
 
   RefPtr<Image> image = videoFrameToImage(video);
   if (!image)
     return;
@@ skipping 56 matching lines @@
                        format, type, xoffset, yoffset, zoffset))
     return;
   ASSERT(bitmap->bitmapImage());
 
   if (functionID != TexSubImage3D && bitmap->isAccelerated() &&
       canUseTexImageByGPU(functionID, internalformat, type)) {
     if (functionID == TexImage2D) {
       texImage2DBase(target, level, internalformat, bitmap->width(),
                      bitmap->height(), 0, format, type, 0);
       texImageByGPU(TexImage2DByGPU, texture, target, level, internalformat,
-                    type, 0, 0, 0, bitmap);
+                    type, 0, 0, 0, bitmap, getTextureSourceSize(bitmap));
     } else if (functionID == TexSubImage2D) {
       texImageByGPU(TexSubImage2DByGPU, texture, target, level, GL_RGBA, type,
-                    xoffset, yoffset, 0, bitmap);
+                    xoffset, yoffset, 0, bitmap, getTextureSourceSize(bitmap));
     }
     return;
   }
   sk_sp<SkImage> skImage = bitmap->bitmapImage()->imageForCurrentFrame();
   SkPixmap pixmap;
   uint8_t* pixelDataPtr = nullptr;
   RefPtr<Uint8Array> pixelData;
   // In the case where an ImageBitmap is not texture backed, peekPixels() always
   // succeed.  However, when it is texture backed and !canUseTexImageByGPU, we
   // do a GPU read back.
@@ skipping 181 matching lines @@
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLenum format,
                                               GLenum type,
                                               HTMLCanvasElement* canvas,
                                               ExceptionState& exceptionState) {
-  texImageHelperHTMLCanvasElement(TexSubImage2D, target, level, 0, format, type,
-                                  xoffset, yoffset, 0, canvas, exceptionState);
+  texImageHelperHTMLCanvasElement(
+      TexSubImage2D, target, level, 0, format, type, xoffset, yoffset, 0,
+      canvas, getTextureSourceSize(canvas), 1, 0, exceptionState);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLenum format,
                                               GLenum type,
                                               HTMLVideoElement* video,
                                               ExceptionState& exceptionState) {
@@ skipping 2236 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink