Implement tex{Sub}Image3D taking sub-rectangles of HTMLImageElements.

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 4329 matching lines @@
     GLint internalformat,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     GLenum format,
     GLenum type,
     Image* image,
     WebGLImageConversion::ImageHtmlDomSource domSource,
     bool flipY,
     bool premultiplyAlpha,
-    const IntRect& sourceImageRect) {
+    const IntRect& sourceImageRect,
+    GLsizei depth,
+    GLint unpackImageHeight) {
   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;
@@ skipping 19 matching lines @@
 
   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");
     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 29 matching lines @@
     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,
                                adjustedSourceImageRect.width(),
                                adjustedSourceImageRect.height(), format, type,
                                needConversion ? data.data() : imagePixelData);
   } else {
-    DCHECK_EQ(functionID, TexSubImage3D);
-    contextGL()->TexSubImage3D(
-        target, level, xoffset, yoffset, zoffset,
-        adjustedSourceImageRect.width(), adjustedSourceImageRect.height(), 1,
-        format, type, needConversion ? data.data() : imagePixelData);
+    // 3D functions.
+    GLint uploadHeight = adjustedSourceImageRect.height();
+    if (unpackImageHeight) {
+      // GL_UNPACK_IMAGE_HEIGHT overrides the passed-in height.
+      uploadHeight = unpackImageHeight;
+    }
+    if (functionID == TexImage3D) {
+      contextGL()->TexImage3D(target, level, internalformat,
+                              adjustedSourceImageRect.width(), uploadHeight,
+                              depth, 0, format, type,
+                              needConversion ? data.data() : imagePixelData);
+    } else {
+      DCHECK_EQ(functionID, TexSubImage3D);
+      contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset,
+                                 adjustedSourceImageRect.width(), uploadHeight,
+                                 depth, format, type,
+                                 needConversion ? data.data() : imagePixelData);
+    }
   }
   restoreUnpackParameters();
 }
 
 bool WebGLRenderingContextBase::validateTexFunc(
     const char* functionName,
     TexImageFunctionType functionType,
     TexFuncValidationSourceType sourceType,
     GLenum target,
     GLint level,
@@ skipping 303 matching lines @@
     GLenum target,
     GLint level,
     GLint internalformat,
     GLenum format,
     GLenum type,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     HTMLImageElement* image,
     const IntRect& sourceImageRect,
+    GLsizei depth,
+    GLint unpackImageHeight,
     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))
+                       imageForRender->height(), depth, 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, sourceImageRect);
+               m_unpackPremultiplyAlpha, sourceImageRect, depth,
+               unpackImageHeight);
 }
 
 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,
-                                 sentinelEmptyRect(), exceptionState);
+                                 sentinelEmptyRect(), 1, 0, exceptionState);
 }
 
 bool WebGLRenderingContextBase::canUseTexImageByGPU(
     TexImageFunctionID functionID,
     GLint internalformat,
     GLenum type) {
   if (functionID == TexImage2D &&
       (isFloatType(type) || isIntegerFormat(internalformat) ||
        isSRGBFormat(internalformat)))
     return false;
@@ skipping 147 matching lines @@
     // 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()));
+                   IntRect(0, 0, canvas->width(), canvas->height()), 1, 0);
       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,
-                 IntRect(0, 0, canvas->width(), canvas->height()));
+                 IntRect(0, 0, canvas->width(), canvas->height()), 1, 0);
   }
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target,
                                            GLint level,
                                            GLint internalformat,
                                            GLenum format,
                                            GLenum type,
                                            HTMLCanvasElement* canvas,
                                            ExceptionState& exceptionState) {
@@ skipping 90 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,
-               IntRect(0, 0, video->videoWidth(), video->videoHeight()));
+               IntRect(0, 0, video->videoWidth(), video->videoHeight()), 1, 0);
 }
 
 void WebGLRenderingContextBase::texImageBitmapByGPU(ImageBitmap* bitmap,
                                                     GLuint targetTexture,
                                                     GLenum targetInternalformat,
                                                     GLenum targetType,
                                                     GLint targetLevel,
                                                     bool flipY) {
   bitmap->bitmapImage()->copyToTexture(drawingBuffer()->contextProvider(),
                                        targetTexture, targetInternalformat,
@@ skipping 231 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,
-                                 sentinelEmptyRect(), exceptionState);
+                                 sentinelEmptyRect(), 1, 0, 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