Implement texture uploads from ImageBitmap with sub source.

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 5245 matching lines @@
     TexImageFunctionID functionID,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLenum format,
     GLenum type,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     ImageBitmap* bitmap,
+    const IntRect& sourceSubRect,
+    GLsizei depth,
+    GLint unpackImageHeight,
     ExceptionState& exceptionState) {
   const char* funcName = getTexImageFunctionName(functionID);
   if (isContextLost())
     return;
   if (!validateImageBitmap(funcName, bitmap, exceptionState))
     return;
   WebGLTexture* texture = validateTexImageBinding(funcName, functionID, target);
   if (!texture)
     return;
+
+  bool selectingSubRectangle = false;
+  if (!validateTexImageSubRectangle(funcName, functionID, bitmap, sourceSubRect,
+                                    depth, unpackImageHeight,
+                                    &selectingSubRectangle)) {
+    return;
+  }
+
   TexImageFunctionType functionType;
   if (functionID == TexImage2D)
     functionType = TexImage;
   else
     functionType = TexSubImage;
+
+  GLsizei width = sourceSubRect.width();
+  GLsizei height = sourceSubRect.height();
   if (!validateTexFunc(funcName, functionType, SourceImageBitmap, target, level,
-                       internalformat, bitmap->width(), bitmap->height(), 1, 0,
-                       format, type, xoffset, yoffset, zoffset))
+                       internalformat, width, height, depth, 0, format, type,
+                       xoffset, yoffset, zoffset))
     return;
   ASSERT(bitmap->bitmapImage());
 
-  if (functionID != TexSubImage3D && bitmap->isAccelerated() &&
-      canUseTexImageByGPU(functionID, internalformat, type)) {
+  if (functionID != TexSubImage3D && functionID != TexImage3D &&
+      bitmap->isAccelerated() &&
+      canUseTexImageByGPU(functionID, internalformat, type) &&
+      !selectingSubRectangle) {
     if (functionID == TexImage2D) {
-      texImage2DBase(target, level, internalformat, bitmap->width(),
-                     bitmap->height(), 0, format, type, 0);
+      texImage2DBase(target, level, internalformat, width, height, 0, format,
+                     type, 0);
       texImageByGPU(TexImage2DByGPU, texture, target, level, internalformat,
-                    type, 0, 0, 0, bitmap, getTextureSourceSize(bitmap));
+                    type, 0, 0, 0, bitmap, sourceSubRect);
     } else if (functionID == TexSubImage2D) {
       texImageByGPU(TexSubImage2DByGPU, texture, target, level, GL_RGBA, type,
-                    xoffset, yoffset, 0, bitmap, getTextureSourceSize(bitmap));
+                    xoffset, yoffset, 0, bitmap, sourceSubRect);
     }
     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.
   bool peekSucceed = skImage->peekPixels(&pixmap);
   if (peekSucceed) {
     pixelDataPtr = static_cast<uint8_t*>(pixmap.writable_addr());
   } else {
     pixelData = bitmap->copyBitmapData(
         bitmap->isPremultiplied() ? PremultiplyAlpha : DontPremultiplyAlpha);
     pixelDataPtr = pixelData->data();
   }
   Vector<uint8_t> data;
   bool needConversion = true;
   bool havePeekableRGBA =
       (peekSucceed &&
        pixmap.colorType() == SkColorType::kRGBA_8888_SkColorType);
   bool isPixelDataRGBA = (havePeekableRGBA || !peekSucceed);
-  if (isPixelDataRGBA && format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
+  if (isPixelDataRGBA && format == GL_RGBA && 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;
     }
-    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(), sourceImageRect, format, type, false, false,
+             bitmap->size(), sourceSubRect, format, type, false, false,
              data)) ||
         (isPixelDataRGBA &&
          !WebGLImageConversion::extractImageData(
              pixelDataPtr, WebGLImageConversion::DataFormat::DataFormatRGBA8,
-             bitmap->size(), sourceImageRect, format, type, false, false,
+             bitmap->size(), sourceSubRect, 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);
+    texImage2DBase(target, level, internalformat, width, height, 0, format,
+                   type, needConversion ? data.data() : pixelDataPtr);
   } else if (functionID == TexSubImage2D) {
-    contextGL()->TexSubImage2D(target, level, xoffset, yoffset, bitmap->width(),
-                               bitmap->height(), format, type,
+    contextGL()->TexSubImage2D(target, level, xoffset, yoffset, width, height,
+                               format, type,
                                needConversion ? data.data() : pixelDataPtr);
+  } else if (functionID == TexImage3D) {
+    contextGL()->TexImage3D(target, level, internalformat, width, height, depth,
+                            0, format, type,
+                            needConversion ? data.data() : pixelDataPtr);
   } else {
     DCHECK_EQ(functionID, TexSubImage3D);
-    contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset,
-                               bitmap->width(), bitmap->height(), 1, format,
-                               type,
+    contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
+                               height, depth, format, type,
                                needConversion ? data.data() : pixelDataPtr);
   }
   restoreUnpackParameters();
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target,
                                            GLint level,
                                            GLint internalformat,
                                            GLenum format,
                                            GLenum type,
                                            ImageBitmap* bitmap,
                                            ExceptionState& exceptionState) {
   texImageHelperImageBitmap(TexImage2D, target, level, internalformat, format,
-                            type, 0, 0, 0, bitmap, exceptionState);
+                            type, 0, 0, 0, bitmap, getTextureSourceSize(bitmap),
+                            1, 0, exceptionState);
 }
 
 void WebGLRenderingContextBase::texParameter(GLenum target,
                                              GLenum pname,
                                              GLfloat paramf,
                                              GLint parami,
                                              bool isFloat) {
   if (isContextLost())
     return;
   if (!validateTextureBinding("texParameter", target))
@@ skipping 130 matching lines @@
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLenum format,
                                               GLenum type,
                                               ImageBitmap* bitmap,
                                               ExceptionState& exceptionState) {
   texImageHelperImageBitmap(TexSubImage2D, target, level, 0, format, type,
-                            xoffset, yoffset, 0, bitmap, exceptionState);
+                            xoffset, yoffset, 0, bitmap,
+                            getTextureSourceSize(bitmap), 1, 0, exceptionState);
 }
 
 void WebGLRenderingContextBase::uniform1f(const WebGLUniformLocation* location,
                                           GLfloat x) {
   if (isContextLost() || !location)
     return;
 
   if (location->program() != m_currentProgram) {
     synthesizeGLError(GL_INVALID_OPERATION, "uniform1f",
                       "location not for current program");
@@ skipping 2234 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink