support 3d texture sub-source uploads from 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 4348 matching lines @@
   }
   Vector<uint8_t> data;
 
   IntRect subRect = sourceImageRect;
   if (subRect == sentinelEmptyRect()) {
     // Recalculate based on the size of the Image.
     subRect = safeGetImageSize(image);
   }
 
   bool selectingSubRectangle = false;
-  if (!validateTexImageSubRectangle(funcName, image, subRect,
+  if (!validateTexImageSubRectangle(funcName, functionID, image, subRect, 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 = subRect.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);
-  }
-
   // 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);
@@ skipping 293 matching lines @@
     GLint level,
     GLint internalformat,
     GLint border,
     GLenum format,
     GLenum type,
     GLsizei depth,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     ImageData* pixels,
-    const IntRect& sourceImageRect) {
+    const IntRect& sourceImageRect,
+    GLint unpackImageHeight) {
   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)
+  if (functionID == TexImage2D || functionID == TexImage3D)
     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,
+  if (!validateTexImageSubRectangle(funcName, functionID, pixels,
+                                    sourceImageRect, depth, unpackImageHeight,
                                     &selectingSubRectangle)) {
     return;
   }
   // Adjust the source image rectangle if doing a y-flip.
   IntRect adjustedSourceImageRect = sourceImageRect;
   if (m_unpackFlipY) {
     adjustedSourceImageRect.setY(pixels->height() -
                                  adjustedSourceImageRect.maxY());
   }
 
@@ skipping 13 matching lines @@
     if (!WebGLImageConversion::extractImageData(
             pixels->data()->data(),
             WebGLImageConversion::DataFormat::DataFormatRGBA8, pixels->size(),
             adjustedSourceImageRect, format, type, m_unpackFlipY,
             m_unpackPremultiplyAlpha, data)) {
       synthesizeGLError(GL_INVALID_VALUE, funcName, "bad image data");
       return;
     }
   }
   resetUnpackParameters();
+  GLint uploadWidth = adjustedSourceImageRect.width();
+  GLint uploadHeight = adjustedSourceImageRect.height();

[Ken Russell (switch to Gerrit), 2016/11/14 21:27:38]

Could you please just put these two definitions into the "else" branch for the
3D case? See texImageImpl.

+  const uint8_t* bytes = needConversion ? data.data() : pixels->data()->data();
   if (functionID == TexImage2D) {
-    texImage2DBase(target, level, internalformat,
-                   adjustedSourceImageRect.width(),
-                   adjustedSourceImageRect.height(), border, format, type,
-                   needConversion ? data.data() : pixels->data()->data());
+    DCHECK_EQ(unpackImageHeight, 0);
+    texImage2DBase(
+        target, level, internalformat, adjustedSourceImageRect.width(),
+        adjustedSourceImageRect.height(), border, format, type, bytes);
   } else if (functionID == TexSubImage2D) {
-    contextGL()->TexSubImage2D(
-        target, level, xoffset, yoffset, adjustedSourceImageRect.width(),
-        adjustedSourceImageRect.height(), format, type,
-        needConversion ? data.data() : pixels->data()->data());
+    DCHECK_EQ(unpackImageHeight, 0);
+    contextGL()->TexSubImage2D(target, level, xoffset, yoffset, uploadWidth,
+                               uploadHeight, format, type, bytes);
   } else {
-    DCHECK_EQ(functionID, TexSubImage3D);
-    contextGL()->TexSubImage3D(
-        target, level, xoffset, yoffset, zoffset,
-        adjustedSourceImageRect.width(), adjustedSourceImageRect.height(),
-        depth, format, type,
-        needConversion ? data.data() : pixels->data()->data());
+    if (unpackImageHeight) {
+      // GL_UNPACK_IMAGE_HEIGHT overrides the passed-in height.
+      uploadHeight = unpackImageHeight;
+    }
+    if (functionID == TexImage3D) {
+      contextGL()->TexImage3D(target, level, internalformat, uploadWidth,
+                              uploadHeight, depth, border, format, type, bytes);
+    } else {
+      DCHECK_EQ(functionID, TexSubImage3D);
+      contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset,
+                                 uploadWidth, uploadHeight, depth, format, type,
+                                 bytes);
+    }
   }
   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, getImageDataSize(pixels));
+                          type, 1, 0, 0, 0, pixels, getImageDataSize(pixels),
+                          0);
 }
 
 void WebGLRenderingContextBase::texImageHelperHTMLImageElement(
     TexImageFunctionID functionID,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLenum format,
     GLenum type,
     GLint xoffset,
@@ skipping 580 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,
-                          getImageDataSize(pixels));
+                          xoffset, yoffset, 0, pixels, getImageDataSize(pixels),
+                          0);
 }
 
 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