Support 2D texture sub-source uploads from HTMLImageElement.

third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/gpu/WebGLImageConversion.h"
 
 #include "platform/graphics/ImageObserver.h"
 #include "platform/graphics/cpu/arm/WebGLImageConversionNEON.h"
 #include "platform/graphics/cpu/mips/WebGLImageConversionMSA.h"
 #include "platform/graphics/cpu/x86/WebGLImageConversionSSE.h"
@@ skipping 2214 matching lines @@
       return 0;
   }
 }
 
 /* END CODE SHARED WITH MOZILLA FIREFOX */
 
 class FormatConverter {
   STACK_ALLOCATED();
 
  public:
-  FormatConverter(unsigned width,
-                  unsigned height,
+  FormatConverter(const IntRect& sourceDataSubRectangle,
                   const void* srcStart,
                   void* dstStart,
                   int srcStride,
+                  int srcRowOffset,
                   int dstStride)
-      : m_width(width),
-        m_height(height),
+      : m_srcSubRectangle(sourceDataSubRectangle),
         m_srcStart(srcStart),
         m_dstStart(dstStart),
         m_srcStride(srcStride),
+        m_srcRowOffset(srcRowOffset),
         m_dstStride(dstStride),
         m_success(false) {
     const unsigned MaxNumberOfComponents = 4;
     const unsigned MaxBytesPerComponent = 4;
     m_unpackedIntermediateSrcData = wrapArrayUnique(
-        new uint8_t[m_width * MaxNumberOfComponents * MaxBytesPerComponent]);
+        new uint8_t[m_srcSubRectangle.width() * MaxNumberOfComponents *
+                    MaxBytesPerComponent]);
     ASSERT(m_unpackedIntermediateSrcData.get());
   }
 
   void convert(WebGLImageConversion::DataFormat srcFormat,
                WebGLImageConversion::DataFormat dstFormat,
                WebGLImageConversion::AlphaOp);
   bool Success() const { return m_success; }
 
  private:
   template <WebGLImageConversion::DataFormat SrcFormat>
   void convert(WebGLImageConversion::DataFormat dstFormat,
                WebGLImageConversion::AlphaOp);
 
   template <WebGLImageConversion::DataFormat SrcFormat,
             WebGLImageConversion::DataFormat DstFormat>
   void convert(WebGLImageConversion::AlphaOp);
 
   template <WebGLImageConversion::DataFormat SrcFormat,
             WebGLImageConversion::DataFormat DstFormat,
             WebGLImageConversion::AlphaOp alphaOp>
   void convert();
 
-  const unsigned m_width, m_height;
+  const IntRect& m_srcSubRectangle;
   const void* const m_srcStart;
   void* const m_dstStart;
-  const int m_srcStride, m_dstStride;
+  const int m_srcStride, m_srcRowOffset, m_dstStride;
   bool m_success;
   std::unique_ptr<uint8_t[]> m_unpackedIntermediateSrcData;
 };
 
 void FormatConverter::convert(WebGLImageConversion::DataFormat srcFormat,
                               WebGLImageConversion::DataFormat dstFormat,
                               WebGLImageConversion::AlphaOp alphaOp) {
 #define FORMATCONVERTER_CASE_SRCFORMAT(SrcFormat) \
   case SrcFormat:                                 \
     return convert<SrcFormat>(dstFormat, alphaOp);
@@ skipping 157 matching lines @@
   typedef typename DataTypeForFormat<DstFormat>::Type DstType;
   const int IntermFormat = IntermediateFormat<DstFormat>::value;
   typedef typename DataTypeForFormat<IntermFormat>::Type IntermType;
   const ptrdiff_t srcStrideInElements = m_srcStride / sizeof(SrcType);
   const ptrdiff_t dstStrideInElements = m_dstStride / sizeof(DstType);
   const bool trivialUnpack = SrcFormat == IntermFormat;
   const bool trivialPack = DstFormat == IntermFormat &&
                            alphaOp == WebGLImageConversion::AlphaDoNothing;
   ASSERT(!trivialUnpack || !trivialPack);
 
-  const SrcType* srcRowStart = static_cast<const SrcType*>(m_srcStart);
+  const SrcType* srcRowStart =
+      static_cast<const SrcType*>(static_cast<const void*>(
+          static_cast<const uint8_t*>(m_srcStart) +
+          ((m_srcStride * m_srcSubRectangle.y()) + m_srcRowOffset)));
   DstType* dstRowStart = static_cast<DstType*>(m_dstStart);
   if (trivialUnpack) {
-    for (size_t i = 0; i < m_height; ++i) {
-      pack<DstFormat, alphaOp>(srcRowStart, dstRowStart, m_width);
+    for (int i = 0; i < m_srcSubRectangle.height(); ++i) {
+      pack<DstFormat, alphaOp>(srcRowStart, dstRowStart,
+                               m_srcSubRectangle.width());
       srcRowStart += srcStrideInElements;
       dstRowStart += dstStrideInElements;
     }
   } else if (trivialPack) {
-    for (size_t i = 0; i < m_height; ++i) {
-      unpack<SrcFormat>(srcRowStart, dstRowStart, m_width);
+    for (int i = 0; i < m_srcSubRectangle.height(); ++i) {
+      unpack<SrcFormat>(srcRowStart, dstRowStart, m_srcSubRectangle.width());
       srcRowStart += srcStrideInElements;
       dstRowStart += dstStrideInElements;
     }
   } else {
-    for (size_t i = 0; i < m_height; ++i) {
+    for (int i = 0; i < m_srcSubRectangle.height(); ++i) {
       unpack<SrcFormat>(srcRowStart, reinterpret_cast<IntermType*>(
                                          m_unpackedIntermediateSrcData.get()),
-                        m_width);
+                        m_srcSubRectangle.width());
       pack<DstFormat, alphaOp>(
           reinterpret_cast<IntermType*>(m_unpackedIntermediateSrcData.get()),
-          dstRowStart, m_width);
+          dstRowStart, m_srcSubRectangle.width());
       srcRowStart += srcStrideInElements;
       dstRowStart += dstStrideInElements;
     }
   }
   m_success = true;
   return;
 }
 
 bool frameIsValid(const SkBitmap& frameBitmap) {
   return !frameBitmap.isNull() && !frameBitmap.empty() &&
@@ skipping 367 matching lines @@
   }
 }
 
 bool WebGLImageConversion::packImageData(Image* image,
                                          const void* pixels,
                                          GLenum format,
                                          GLenum type,
                                          bool flipY,
                                          AlphaOp alphaOp,
                                          DataFormat sourceFormat,
-                                         unsigned width,
-                                         unsigned height,
+                                         unsigned sourceImageWidth,
+                                         unsigned sourceImageHeight,
+                                         const IntRect& sourceImageSubRectangle,
                                          unsigned sourceUnpackAlignment,
                                          Vector<uint8_t>& data) {
   if (!pixels)
     return false;
 
   unsigned packedSize;
   // Output data is tightly packed (alignment == 1).
   PixelStoreParams params;
   params.alignment = 1;
-  if (computeImageSizeInBytes(format, type, width, height, 1, params,
+  if (computeImageSizeInBytes(format, type, sourceImageSubRectangle.width(),
+                              sourceImageSubRectangle.height(), 1, params,
                               &packedSize, 0, 0) != GL_NO_ERROR)
     return false;
   data.resize(packedSize);
 
-  if (!packPixels(reinterpret_cast<const uint8_t*>(pixels), sourceFormat, width,
-                  height, sourceUnpackAlignment, format, type, alphaOp,
-                  data.data(), flipY))
+  if (!packPixels(reinterpret_cast<const uint8_t*>(pixels), sourceFormat,
+                  sourceImageWidth, sourceImageHeight, sourceImageSubRectangle,
+                  sourceUnpackAlignment, format, type, alphaOp, data.data(),
+                  flipY))
     return false;
   if (ImageObserver* observer = image->getImageObserver())
     observer->didDraw(image);
   return true;
 }
 
 bool WebGLImageConversion::extractImageData(const uint8_t* imageData,
                                             DataFormat sourceDataFormat,
                                             const IntSize& imageDataSize,
                                             GLenum format,
                                             GLenum type,
                                             bool flipY,
                                             bool premultiplyAlpha,
                                             Vector<uint8_t>& data) {
   if (!imageData)
     return false;
   int width = imageDataSize.width();
   int height = imageDataSize.height();
 
   unsigned packedSize;
   // Output data is tightly packed (alignment == 1).
   PixelStoreParams params;
   params.alignment = 1;
   if (computeImageSizeInBytes(format, type, width, height, 1, params,
                               &packedSize, 0, 0) != GL_NO_ERROR)
     return false;
   data.resize(packedSize);
 
-  if (!packPixels(imageData, sourceDataFormat, width, height, 0, format, type,
+  if (!packPixels(imageData, sourceDataFormat, width, height,
+                  IntRect(0, 0, width, height), 0, format, type,
                   premultiplyAlpha ? AlphaDoPremultiply : AlphaDoNothing,
                   data.data(), flipY))
     return false;
 
   return true;
 }
 
 bool WebGLImageConversion::extractTextureData(unsigned width,
                                               unsigned height,
                                               GLenum format,
                                               GLenum type,
                                               unsigned unpackAlignment,
                                               bool flipY,
                                               bool premultiplyAlpha,
                                               const void* pixels,
                                               Vector<uint8_t>& data) {
   // Assumes format, type, etc. have already been validated.
   DataFormat sourceDataFormat = getDataFormat(format, type);
 
   // Resize the output buffer.
   unsigned int componentsPerPixel, bytesPerComponent;
   if (!computeFormatAndTypeParameters(format, type, &componentsPerPixel,
                                       &bytesPerComponent))
     return false;
   unsigned bytesPerPixel = componentsPerPixel * bytesPerComponent;
   data.resize(width * height * bytesPerPixel);
 
   if (!packPixels(static_cast<const uint8_t*>(pixels), sourceDataFormat, width,
-                  height, unpackAlignment, format, type,
+                  height, IntRect(0, 0, width, height), unpackAlignment, format,
+                  type,
                   (premultiplyAlpha ? AlphaDoPremultiply : AlphaDoNothing),
                   data.data(), flipY))
     return false;
 
   return true;
 }
 
 bool WebGLImageConversion::packPixels(const uint8_t* sourceData,
                                       DataFormat sourceDataFormat,
-                                      unsigned width,
-                                      unsigned height,
+                                      unsigned sourceDataWidth,
+                                      unsigned sourceDataHeight,
+                                      const IntRect& sourceDataSubRectangle,
                                       unsigned sourceUnpackAlignment,
                                       unsigned destinationFormat,
                                       unsigned destinationType,
                                       AlphaOp alphaOp,
                                       void* destinationData,
                                       bool flipY) {
-  int validSrc = width * TexelBytesForFormat(sourceDataFormat);
+  int validSrc = sourceDataWidth * TexelBytesForFormat(sourceDataFormat);
   int remainder =
       sourceUnpackAlignment ? (validSrc % sourceUnpackAlignment) : 0;
   int srcStride =
       remainder ? (validSrc + sourceUnpackAlignment - remainder) : validSrc;
+  int srcRowOffset =
+      sourceDataSubRectangle.x() * TexelBytesForFormat(sourceDataFormat);
 
   DataFormat dstDataFormat = getDataFormat(destinationFormat, destinationType);
-  int dstStride = width * TexelBytesForFormat(dstDataFormat);
+  int dstStride =
+      sourceDataSubRectangle.width() * TexelBytesForFormat(dstDataFormat);
   if (flipY) {
-    destinationData =
-        static_cast<uint8_t*>(destinationData) + dstStride * (height - 1);
+    destinationData = static_cast<uint8_t*>(destinationData) +
+                      dstStride * (sourceDataSubRectangle.height() - 1);
     dstStride = -dstStride;
   }
   if (!HasAlpha(sourceDataFormat) || !HasColor(sourceDataFormat) ||
       !HasColor(dstDataFormat))
     alphaOp = AlphaDoNothing;
 
   if (sourceDataFormat == dstDataFormat && alphaOp == AlphaDoNothing) {
-    const uint8_t* ptr = sourceData;
-    const uint8_t* ptrEnd = sourceData + srcStride * height;
+    const uint8_t* ptr = sourceData + srcStride * sourceDataSubRectangle.y();
+    const uint8_t* ptrEnd =
+        sourceData + srcStride * sourceDataSubRectangle.maxY();
     unsigned rowSize = (dstStride > 0) ? dstStride : -dstStride;
     uint8_t* dst = static_cast<uint8_t*>(destinationData);
     while (ptr < ptrEnd) {
-      memcpy(dst, ptr, rowSize);
+      memcpy(dst, ptr + srcRowOffset, rowSize);
       ptr += srcStride;
       dst += dstStride;
     }
     return true;
   }
 
-  FormatConverter converter(width, height, sourceData, destinationData,
-                            srcStride, dstStride);
+  FormatConverter converter(sourceDataSubRectangle, sourceData, destinationData,
+                            srcStride, srcRowOffset, dstStride);
   converter.convert(sourceDataFormat, dstDataFormat, alphaOp);
   if (!converter.Success())
     return false;
   return true;
 }
 
 void WebGLImageConversion::unpackPixels(const uint16_t* sourceData,
                                         DataFormat sourceDataFormat,
                                         unsigned pixelsPerRow,
                                         uint8_t* destinationData) {
@@ skipping 89 matching lines @@
       pack<WebGLImageConversion::DataFormatRGB565,
            WebGLImageConversion::AlphaDoNothing>(srcRowStart, dstRowStart,
                                                  pixelsPerRow);
     } break;
     default:
       break;
   }
 }
 
 }  // namespace blink