Support 2D texture sub-source uploads from HTMLImageElement.

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 4315 matching lines @@
     GLint level,
     GLint internalformat,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     GLenum format,
     GLenum type,
     Image* image,
     WebGLImageConversion::ImageHtmlDomSource domSource,
     bool flipY,
-    bool premultiplyAlpha) {
+    bool premultiplyAlpha,
+    const IntRect& sourceImageRect) {
   const char* funcName = getTexImageFunctionName(functionID);
   // All calling functions check isContextLost, so a duplicate check is not
   // needed here.
   if (type == GL_UNSIGNED_INT_10F_11F_11F_REV) {
     // The UNSIGNED_INT_10F_11F_11F_REV type pack/unpack isn't implemented.
     type = GL_FLOAT;
   }
   Vector<uint8_t> data;
+
+  IntRect subRect = sourceImageRect;
+  if (subRect == sentinelEmptyRect()) {
+    // Recalculate based on the size of the Image.
+    subRect = safeGetImageSize(image);
+  }
+
+  bool selectingSubRectangle = image &&
+                               !(subRect.x() == 0 && subRect.y() == 0 &&
+                                 subRect.width() == image->width() &&
+                                 subRect.height() == image->height());
+  // If the source image rect selects anything except the entire
+  // contents of the image, assert that we're running WebGL 2.0 or
+  // higher, since this should never happen for WebGL 1.0 (even though
+  // the code could support it). If the image is null, that will be
+  // signaled as an error later.
+  DCHECK(!selectingSubRectangle || isWebGL2OrHigher())
+      << "subRect = (" << subRect.width() << " x " << subRect.height()
+      << ") @ (" << subRect.x() << ", " << subRect.y() << "), image = ("
+      << (image ? image->width() : -1) << " x "
+      << (image ? image->height() : -1) << ")";
+
+  if (subRect.x() < 0 || subRect.y() < 0 || subRect.maxX() > image->width() ||
+      subRect.maxY() > image->height() || subRect.width() < 0 ||
+      subRect.height() < 0) {
+    synthesizeGLError(GL_INVALID_OPERATION, funcName,

[Zhenyao Mo, 2016/10/31 22:50:51]

Should we generate INVALID_VALUE here? subRect's width() and height() is the
original args width/height, which generates INVALID_VALUE if negative.

[Ken Russell (switch to Gerrit), 2016/11/01 00:31:34]

Thanks, good point; I'll address this in a follow-on patch (and test it).

+                      "source sub-rectangle specified via pixel unpack "
+                      "parameters is invalid");
+    return;
+  }
+
+  // Adjust the source image rectangle if doing a y-flip.
+  IntRect adjustedSourceImageRect = subRect;
+  if (flipY) {
+    adjustedSourceImageRect.setY(image->height() -
+                                 adjustedSourceImageRect.maxY());
+  }
+
   WebGLImageConversion::ImageExtractor imageExtractor(
       image, domSource, premultiplyAlpha,
       m_unpackColorspaceConversion == GL_NONE);
   if (!imageExtractor.imagePixelData()) {
     synthesizeGLError(GL_INVALID_VALUE, funcName, "bad image data");
     return;
   }
+
   WebGLImageConversion::DataFormat sourceDataFormat =
       imageExtractor.imageSourceFormat();
   WebGLImageConversion::AlphaOp alphaOp = imageExtractor.imageAlphaOp();
   const void* imagePixelData = imageExtractor.imagePixelData();
 
   bool needConversion = true;
   if (type == GL_UNSIGNED_BYTE &&
       sourceDataFormat == WebGLImageConversion::DataFormatRGBA8 &&
       format == GL_RGBA && alphaOp == WebGLImageConversion::AlphaDoNothing &&
-      !flipY) {
+      !flipY && !selectingSubRectangle) {
     needConversion = false;
   } else {
     if (!WebGLImageConversion::packImageData(
             image, imagePixelData, format, type, flipY, alphaOp,
             sourceDataFormat, imageExtractor.imageWidth(),
-            imageExtractor.imageHeight(),
+            imageExtractor.imageHeight(), adjustedSourceImageRect,
             imageExtractor.imageSourceUnpackAlignment(), data)) {
       synthesizeGLError(GL_INVALID_VALUE, funcName, "packImage error");
       return;
     }
   }
 
   resetUnpackParameters();
   if (functionID == TexImage2D) {
-    texImage2DBase(target, level, internalformat, imageExtractor.imageWidth(),
-                   imageExtractor.imageHeight(), 0, format, type,
+    texImage2DBase(target, level, internalformat,
+                   adjustedSourceImageRect.width(),
+                   adjustedSourceImageRect.height(), 0, format, type,
                    needConversion ? data.data() : imagePixelData);
   } else if (functionID == TexSubImage2D) {
     contextGL()->TexSubImage2D(target, level, xoffset, yoffset,
-                               imageExtractor.imageWidth(),
-                               imageExtractor.imageHeight(), format, type,
+                               adjustedSourceImageRect.width(),
+                               adjustedSourceImageRect.height(), format, type,
                                needConversion ? data.data() : imagePixelData);
   } else {
     DCHECK_EQ(functionID, TexSubImage3D);
-    contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset,
-                               imageExtractor.imageWidth(),
-                               imageExtractor.imageHeight(), 1, format, type,
-                               needConversion ? data.data() : imagePixelData);
+    contextGL()->TexSubImage3D(
+        target, level, xoffset, yoffset, zoffset,
+        adjustedSourceImageRect.width(), adjustedSourceImageRect.height(), 1,
+        format, type, needConversion ? data.data() : imagePixelData);
   }
   restoreUnpackParameters();
 }
 
 bool WebGLRenderingContextBase::validateTexFunc(
     const char* functionName,
     TexImageFunctionType functionType,
     TexFuncValidationSourceType sourceType,
     GLenum target,
     GLint level,
@@ skipping 96 matching lines @@
       return "texSubImage2D";
     case TexSubImage3D:
       return "texSubImage3D";
     case TexImage3D:
       return "texImage3D";
     default:  // Adding default to prevent compile error
       return "";
   }
 }
 
+IntRect WebGLRenderingContextBase::sentinelEmptyRect() {
+  // Return a rectangle with -1 width and height so we can recognize
+  // 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());
+}
+
 void WebGLRenderingContextBase::texImageHelperDOMArrayBufferView(
     TexImageFunctionID functionID,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
     GLenum format,
@@ skipping 174 matching lines @@
     TexImageFunctionID functionID,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLenum format,
     GLenum type,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     HTMLImageElement* image,
+    const IntRect& sourceImageRect,
     ExceptionState& exceptionState) {
   const char* funcName = getTexImageFunctionName(functionID);
   if (isContextLost())
     return;
   if (!validateHTMLImageElement(funcName, image, exceptionState))
     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)
     functionType = TexImage;
   else
     functionType = TexSubImage;
   if (!imageForRender ||
       !validateTexFunc(funcName, functionType, SourceHTMLImageElement, target,
                        level, internalformat, imageForRender->width(),
                        imageForRender->height(), 1, 0, format, type, xoffset,
                        yoffset, zoffset))
     return;
 
   texImageImpl(functionID, target, level, internalformat, xoffset, yoffset,
                zoffset, format, type, imageForRender.get(),
                WebGLImageConversion::HtmlDomImage, m_unpackFlipY,
-               m_unpackPremultiplyAlpha);
+               m_unpackPremultiplyAlpha, sourceImageRect);
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target,
                                            GLint level,
                                            GLint internalformat,
                                            GLenum format,
                                            GLenum type,
                                            HTMLImageElement* image,
                                            ExceptionState& exceptionState) {
   texImageHelperHTMLImageElement(TexImage2D, target, level, internalformat,
-                                 format, type, 0, 0, 0, image, exceptionState);
+                                 format, type, 0, 0, 0, image,
+                                 sentinelEmptyRect(), exceptionState);
 }
 
 bool WebGLRenderingContextBase::canUseTexImageByGPU(
     TexImageFunctionID functionID,
     GLint internalformat,
     GLenum type) {
   if (functionID == TexImage2D &&
       (isFloatType(type) || isIntegerFormat(internalformat) ||
        isSRGBFormat(internalformat)))
     return false;
@@ skipping 146 matching lines @@
     // 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);
+                   m_unpackPremultiplyAlpha,
+                   IntRect(0, 0, canvas->width(), canvas->height()));
       return;
     }
 
     if (functionID == TexImage2D) {
       texImage2DBase(target, level, internalformat, canvas->width(),
                      canvas->height(), 0, format, type, 0);
       texImageByGPU(TexImage2DByGPU, texture, target, level, internalformat,
                     type, 0, 0, 0, canvas);
     } else {
       texImageByGPU(TexSubImage2DByGPU, texture, target, level, GL_RGBA, type,
                     xoffset, yoffset, 0, canvas);
     }
   } 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,
                  canvas->copiedImage(FrontBuffer, PreferAcceleration).get(),
                  WebGLImageConversion::HtmlDomCanvas, m_unpackFlipY,
-                 m_unpackPremultiplyAlpha);
+                 m_unpackPremultiplyAlpha,
+                 IntRect(0, 0, canvas->width(), canvas->height()));
   }
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target,
                                            GLint level,
                                            GLint internalformat,
                                            GLenum format,
                                            GLenum type,
                                            HTMLCanvasElement* canvas,
                                            ExceptionState& exceptionState) {
@@ skipping 89 matching lines @@
       }
     }
   }
 
   RefPtr<Image> image = videoFrameToImage(video);
   if (!image)
     return;
   texImageImpl(functionID, target, level, internalformat, xoffset, yoffset,
                zoffset, format, type, image.get(),
                WebGLImageConversion::HtmlDomVideo, m_unpackFlipY,
-               m_unpackPremultiplyAlpha);
+               m_unpackPremultiplyAlpha,
+               IntRect(0, 0, video->videoWidth(), video->videoHeight()));
 }
 
 void WebGLRenderingContextBase::texImageBitmapByGPU(ImageBitmap* bitmap,
                                                     GLuint targetTexture,
                                                     GLenum targetInternalformat,
                                                     GLenum targetType,
                                                     GLint targetLevel,
                                                     bool flipY) {
   bitmap->bitmapImage()->copyToTexture(drawingBuffer()->contextProvider(),
                                        targetTexture, targetInternalformat,
@@ skipping 230 matching lines @@
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLenum format,
                                               GLenum type,
                                               HTMLImageElement* image,
                                               ExceptionState& exceptionState) {
   texImageHelperHTMLImageElement(TexSubImage2D, target, level, 0, format, type,
-                                 xoffset, yoffset, 0, image, exceptionState);
+                                 xoffset, yoffset, 0, image,
+                                 sentinelEmptyRect(), exceptionState);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLenum format,
                                               GLenum type,
                                               HTMLCanvasElement* canvas,
                                               ExceptionState& exceptionState) {
@@ skipping 2248 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink