support uploading sub-rectangles of ImageData

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 4347 matching lines @@
     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,
-                      "source sub-rectangle specified via pixel unpack "
-                      "parameters is invalid");
+  bool selectingSubRectangle = false;
+  if (!validateTexImageSubRectangle(funcName, image, subRect,
+                                    &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 = subRect.height();
@@ skipping 203 matching lines @@
   return IntRect(0, 0, -1, -1);
 }
 
 IntRect WebGLRenderingContextBase::safeGetImageSize(Image* image) {
   if (!image)
     return IntRect();
 
   return IntRect(0, 0, image->width(), image->height());
 }
 
+IntRect WebGLRenderingContextBase::getImageDataSize(ImageData* pixels) {
+  DCHECK(pixels);
+  return IntRect(0, 0, pixels->width(), pixels->height());
+}
+
 void WebGLRenderingContextBase::texImageHelperDOMArrayBufferView(
     TexImageFunctionID functionID,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
     GLenum format,
@@ skipping 89 matching lines @@
     GLenum target,
     GLint level,
     GLint internalformat,
     GLint border,
     GLenum format,
     GLenum type,
     GLsizei depth,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
-    ImageData* pixels) {
+    ImageData* pixels,
+    const IntRect& sourceImageRect) {
   const char* funcName = getTexImageFunctionName(functionID);
   if (isContextLost())
     return;
   DCHECK(pixels);
   if (pixels->data()->bufferBase()->isNeutered()) {
     synthesizeGLError(GL_INVALID_VALUE, funcName,
                       "The source data has been neutered.");
     return;
   }
   if (!validateTexImageBinding(funcName, functionID, target))
     return;
   TexImageFunctionType functionType;
   if (functionID == TexImage2D)
     functionType = TexImage;
   else
     functionType = TexSubImage;
   if (!validateTexFunc(funcName, functionType, SourceImageData, target, level,
                        internalformat, pixels->width(), pixels->height(), depth,
                        border, format, type, xoffset, yoffset, zoffset))
     return;
+
+  bool selectingSubRectangle = false;
+  if (!validateTexImageSubRectangle(funcName, pixels, sourceImageRect,
+                                    &selectingSubRectangle)) {
+    return;
+  }
+  // Adjust the source image rectangle if doing a y-flip.
+  IntRect adjustedSourceImageRect = sourceImageRect;
+  if (m_unpackFlipY) {
+    adjustedSourceImageRect.setY(pixels->height() -
+                                 adjustedSourceImageRect.maxY());
+  }
+
   Vector<uint8_t> data;
   bool needConversion = true;
   // The data from ImageData is always of format RGBA8.
   // No conversion is needed if destination format is RGBA and type is
-  // USIGNED_BYTE and no Flip or Premultiply operation is required.
+  // UNSIGNED_BYTE and no Flip or Premultiply operation is required.
   if (!m_unpackFlipY && !m_unpackPremultiplyAlpha && format == GL_RGBA &&
-      type == GL_UNSIGNED_BYTE) {
+      type == GL_UNSIGNED_BYTE && !selectingSubRectangle) {
     needConversion = false;
   } else {
     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;
     }
     if (!WebGLImageConversion::extractImageData(
             pixels->data()->data(),
             WebGLImageConversion::DataFormat::DataFormatRGBA8, pixels->size(),
-            format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {
+            adjustedSourceImageRect, format, type, m_unpackFlipY,
+            m_unpackPremultiplyAlpha, data)) {
       synthesizeGLError(GL_INVALID_VALUE, funcName, "bad image data");
       return;
     }
   }
   resetUnpackParameters();
   if (functionID == TexImage2D) {
-    texImage2DBase(target, level, internalformat, pixels->width(),
-                   pixels->height(), border, format, type,
+    texImage2DBase(target, level, internalformat,
+                   adjustedSourceImageRect.width(),
+                   adjustedSourceImageRect.height(), border, format, type,
                    needConversion ? data.data() : pixels->data()->data());
   } else if (functionID == TexSubImage2D) {
     contextGL()->TexSubImage2D(
-        target, level, xoffset, yoffset, pixels->width(), pixels->height(),
-        format, type, needConversion ? data.data() : pixels->data()->data());
+        target, level, xoffset, yoffset, adjustedSourceImageRect.width(),
+        adjustedSourceImageRect.height(), format, type,
+        needConversion ? data.data() : pixels->data()->data());
   } else {
     DCHECK_EQ(functionID, TexSubImage3D);
     contextGL()->TexSubImage3D(
-        target, level, xoffset, yoffset, zoffset, pixels->width(),
-        pixels->height(), depth, format, type,
+        target, level, xoffset, yoffset, zoffset,
+        adjustedSourceImageRect.width(), adjustedSourceImageRect.height(),
+        depth, format, type,
         needConversion ? data.data() : pixels->data()->data());
   }
   restoreUnpackParameters();
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target,
                                            GLint level,
                                            GLint internalformat,
                                            GLenum format,
                                            GLenum type,
                                            ImageData* pixels) {
   texImageHelperImageData(TexImage2D, target, level, internalformat, 0, format,
-                          type, 1, 0, 0, 0, pixels);
+                          type, 1, 0, 0, 0, pixels, getImageDataSize(pixels));
 }
 
 void WebGLRenderingContextBase::texImageHelperHTMLImageElement(
     TexImageFunctionID functionID,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLenum format,
     GLenum type,
     GLint xoffset,
@@ skipping 435 matching lines @@
       (peekSucceed &&
        pixmap.colorType() == SkColorType::kRGBA_8888_SkColorType);
   bool isPixelDataRGBA = (havePeekableRGBA || !peekSucceed);
   if (isPixelDataRGBA && format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
     needConversion = false;
   } else {
     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;
     }
+    IntRect sourceImageRect(0, 0, bitmap->width(), bitmap->height());
     // In the case of ImageBitmap, we do not need to apply flipY or
     // premultiplyAlpha.
     bool isPixelDataBGRA =
         pixmap.colorType() == SkColorType::kBGRA_8888_SkColorType;
     if ((isPixelDataBGRA &&
          !WebGLImageConversion::extractImageData(
              pixelDataPtr, WebGLImageConversion::DataFormat::DataFormatBGRA8,
-             bitmap->size(), format, type, false, false, data)) ||
+             bitmap->size(), sourceImageRect, format, type, false, false,
+             data)) ||
         (isPixelDataRGBA &&
          !WebGLImageConversion::extractImageData(
              pixelDataPtr, WebGLImageConversion::DataFormat::DataFormatRGBA8,
-             bitmap->size(), format, type, false, false, data))) {
+             bitmap->size(), sourceImageRect, format, type, false, false,
+             data))) {
       synthesizeGLError(GL_INVALID_VALUE, funcName, "bad image data");
       return;
     }
   }
   resetUnpackParameters();
   if (functionID == TexImage2D) {
     texImage2DBase(target, level, internalformat, bitmap->width(),
                    bitmap->height(), 0, format, type,
                    needConversion ? data.data() : pixelDataPtr);
   } else if (functionID == TexSubImage2D) {
@@ skipping 110 matching lines @@
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLenum format,
                                               GLenum type,
                                               ImageData* pixels) {
   texImageHelperImageData(TexSubImage2D, target, level, 0, 0, format, type, 1,
-                          xoffset, yoffset, 0, pixels);
+                          xoffset, yoffset, 0, pixels,
+                          getImageDataSize(pixels));
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLenum format,
                                               GLenum type,
                                               HTMLImageElement* image,
                                               ExceptionState& exceptionState) {
@@ skipping 2261 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink