Fix semantics of uploading HTML sources to 3D textures.

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 2215 matching lines @@
   }
 }
 
 /* END CODE SHARED WITH MOZILLA FIREFOX */
 
 class FormatConverter {
   STACK_ALLOCATED();
 
  public:
   FormatConverter(const IntRect& sourceDataSubRectangle,
+                  int depth,
+                  int unpackImageHeight,
                   const void* srcStart,
                   void* dstStart,
                   int srcStride,
                   int srcRowOffset,
                   int dstStride)
       : m_srcSubRectangle(sourceDataSubRectangle),
+        m_depth(depth),
+        m_unpackImageHeight(unpackImageHeight),
         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_srcSubRectangle.width() * MaxNumberOfComponents *
@@ skipping 14 matching lines @@
   template <WebGLImageConversion::DataFormat SrcFormat,
             WebGLImageConversion::DataFormat DstFormat>
   void convert(WebGLImageConversion::AlphaOp);
 
   template <WebGLImageConversion::DataFormat SrcFormat,
             WebGLImageConversion::DataFormat DstFormat,
             WebGLImageConversion::AlphaOp alphaOp>
   void convert();
 
   const IntRect& m_srcSubRectangle;
+  const int m_depth;
+  const int m_unpackImageHeight;
   const void* const m_srcStart;
   void* const m_dstStart;
   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) {
@@ skipping 164 matching lines @@
   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*>(static_cast<const void*>(
           static_cast<const uint8_t*>(m_srcStart) +
           ((m_srcStride * m_srcSubRectangle.y()) + m_srcRowOffset)));
+
+  // If packing multiple images into a 3D texture, and flipY is true,
+  // then the sub-rectangle is pointing at the start of the
+  // "bottommost" of those images. Since the source pointer strides in
+  // the positive direction, we need to back it up to point at the
+  // last, or "topmost", of these images.
+  if (m_dstStride < 0 && m_depth > 1) {
+    srcRowStart -= (m_depth - 1) * srcStrideInElements * m_unpackImageHeight;
+  }
+
   DstType* dstRowStart = static_cast<DstType*>(m_dstStart);
   if (trivialUnpack) {
-    for (int i = 0; i < m_srcSubRectangle.height(); ++i) {
-      pack<DstFormat, alphaOp>(srcRowStart, dstRowStart,
-                               m_srcSubRectangle.width());
-      srcRowStart += srcStrideInElements;
-      dstRowStart += dstStrideInElements;
+    for (int d = 0; d < m_depth; ++d) {
+      for (int i = 0; i < m_srcSubRectangle.height(); ++i) {
+        pack<DstFormat, alphaOp>(srcRowStart, dstRowStart,
+                                 m_srcSubRectangle.width());
+        srcRowStart += srcStrideInElements;
+        dstRowStart += dstStrideInElements;
+      }
+      srcRowStart += srcStrideInElements *
+                     (m_unpackImageHeight - m_srcSubRectangle.height());
     }
   } else if (trivialPack) {
-    for (int i = 0; i < m_srcSubRectangle.height(); ++i) {
-      unpack<SrcFormat>(srcRowStart, dstRowStart, m_srcSubRectangle.width());
-      srcRowStart += srcStrideInElements;
-      dstRowStart += dstStrideInElements;
+    for (int d = 0; d < m_depth; ++d) {
+      for (int i = 0; i < m_srcSubRectangle.height(); ++i) {
+        unpack<SrcFormat>(srcRowStart, dstRowStart, m_srcSubRectangle.width());
+        srcRowStart += srcStrideInElements;
+        dstRowStart += dstStrideInElements;
+      }
+      srcRowStart += srcStrideInElements *
+                     (m_unpackImageHeight - m_srcSubRectangle.height());
     }
   } else {
-    for (int i = 0; i < m_srcSubRectangle.height(); ++i) {
-      unpack<SrcFormat>(srcRowStart, reinterpret_cast<IntermType*>(
-                                         m_unpackedIntermediateSrcData.get()),
-                        m_srcSubRectangle.width());
-      pack<DstFormat, alphaOp>(
-          reinterpret_cast<IntermType*>(m_unpackedIntermediateSrcData.get()),
-          dstRowStart, m_srcSubRectangle.width());
-      srcRowStart += srcStrideInElements;
-      dstRowStart += dstStrideInElements;
+    for (int d = 0; d < m_depth; ++d) {
+      for (int i = 0; i < m_srcSubRectangle.height(); ++i) {
+        unpack<SrcFormat>(srcRowStart, reinterpret_cast<IntermType*>(
+                                           m_unpackedIntermediateSrcData.get()),
+                          m_srcSubRectangle.width());
+        pack<DstFormat, alphaOp>(
+            reinterpret_cast<IntermType*>(m_unpackedIntermediateSrcData.get()),
+            dstRowStart, m_srcSubRectangle.width());
+        srcRowStart += srcStrideInElements;
+        dstRowStart += dstStrideInElements;
+      }
+      srcRowStart += srcStrideInElements *
+                     (m_unpackImageHeight - m_srcSubRectangle.height());
     }
   }
   m_success = true;
   return;
 }
 
 bool frameIsValid(const SkBitmap& frameBitmap) {
   return !frameBitmap.isNull() && !frameBitmap.empty() &&
          frameBitmap.colorType() == kN32_SkColorType;
 }
@@ skipping 368 matching lines @@
 bool WebGLImageConversion::packImageData(Image* image,
                                          const void* pixels,
                                          GLenum format,
                                          GLenum type,
                                          bool flipY,
                                          AlphaOp alphaOp,
                                          DataFormat sourceFormat,
                                          unsigned sourceImageWidth,
                                          unsigned sourceImageHeight,
                                          const IntRect& sourceImageSubRectangle,
+                                         int depth,
                                          unsigned sourceUnpackAlignment,
+                                         int unpackImageHeight,
                                          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, sourceImageSubRectangle.width(),
-                              sourceImageSubRectangle.height(), 1, params,
+                              sourceImageSubRectangle.height(), depth, params,
                               &packedSize, 0, 0) != GL_NO_ERROR)
     return false;
   data.resize(packedSize);
 
   if (!packPixels(reinterpret_cast<const uint8_t*>(pixels), sourceFormat,
                   sourceImageWidth, sourceImageHeight, sourceImageSubRectangle,
-                  sourceUnpackAlignment, format, type, alphaOp, data.data(),
-                  flipY))
+                  depth, sourceUnpackAlignment, unpackImageHeight, 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,
-                                            const IntRect& sourceImageSubRect,
-                                            GLenum format,
-                                            GLenum type,
-                                            bool flipY,
-                                            bool premultiplyAlpha,
-                                            Vector<uint8_t>& data) {
+bool WebGLImageConversion::extractImageData(
+    const uint8_t* imageData,
+    DataFormat sourceDataFormat,
+    const IntSize& imageDataSize,
+    const IntRect& sourceImageSubRectangle,
+    int depth,
+    int unpackImageHeight,
+    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, sourceImageSubRect.width(),
-                              sourceImageSubRect.height(), 1, params,
+  if (computeImageSizeInBytes(format, type, sourceImageSubRectangle.width(),
+                              sourceImageSubRectangle.height(), depth, params,
                               &packedSize, 0, 0) != GL_NO_ERROR)
     return false;
   data.resize(packedSize);
 
   if (!packPixels(imageData, sourceDataFormat, width, height,
-                  sourceImageSubRect, 0, format, type,
-                  premultiplyAlpha ? AlphaDoPremultiply : AlphaDoNothing,
+                  sourceImageSubRectangle, depth, 0, unpackImageHeight, 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, IntRect(0, 0, width, height), unpackAlignment, format,
-                  type,
+                  height, IntRect(0, 0, width, height), 1, unpackAlignment, 0,
+                  format, type,
                   (premultiplyAlpha ? AlphaDoPremultiply : AlphaDoNothing),
                   data.data(), flipY))
     return false;
 
   return true;
 }
 
 bool WebGLImageConversion::packPixels(const uint8_t* sourceData,
                                       DataFormat sourceDataFormat,
                                       unsigned sourceDataWidth,
                                       unsigned sourceDataHeight,
                                       const IntRect& sourceDataSubRectangle,
+                                      int depth,
                                       unsigned sourceUnpackAlignment,
+                                      int unpackImageHeight,
                                       unsigned destinationFormat,
                                       unsigned destinationType,
                                       AlphaOp alphaOp,
                                       void* destinationData,
                                       bool flipY) {
+  DCHECK_GE(depth, 1);
+  if (unpackImageHeight == 0) {
+    unpackImageHeight = sourceDataSubRectangle.height();
+  }
   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 =
       sourceDataSubRectangle.width() * TexelBytesForFormat(dstDataFormat);
   if (flipY) {
-    destinationData = static_cast<uint8_t*>(destinationData) +
-                      dstStride * (sourceDataSubRectangle.height() - 1);
+    destinationData =
+        static_cast<uint8_t*>(destinationData) +
+        dstStride * ((depth * sourceDataSubRectangle.height()) - 1);
     dstStride = -dstStride;
   }
   if (!HasAlpha(sourceDataFormat) || !HasColor(sourceDataFormat) ||
       !HasColor(dstDataFormat))
     alphaOp = AlphaDoNothing;
 
   if (sourceDataFormat == dstDataFormat && alphaOp == AlphaDoNothing) {
-    const uint8_t* ptr = sourceData + srcStride * sourceDataSubRectangle.y();
-    const uint8_t* ptrEnd =
+    const uint8_t* basePtr =
+        sourceData + srcStride * sourceDataSubRectangle.y();
+    const uint8_t* baseEnd =
         sourceData + srcStride * sourceDataSubRectangle.maxY();
+
+    // If packing multiple images into a 3D texture, and flipY is true,
+    // then the sub-rectangle is pointing at the start of the
+    // "bottommost" of those images. Since the source pointer strides in
+    // the positive direction, we need to back it up to point at the
+    // last, or "topmost", of these images.
+    if (flipY && depth > 1) {
+      const ptrdiff_t distanceToTopImage =
+          (depth - 1) * srcStride * unpackImageHeight;
+      basePtr -= distanceToTopImage;
+      baseEnd -= distanceToTopImage;
+    }
+
     unsigned rowSize = (dstStride > 0) ? dstStride : -dstStride;
     uint8_t* dst = static_cast<uint8_t*>(destinationData);
-    while (ptr < ptrEnd) {
-      memcpy(dst, ptr + srcRowOffset, rowSize);
-      ptr += srcStride;
-      dst += dstStride;
+
+    for (int i = 0; i < depth; ++i) {
+      const uint8_t* ptr = basePtr;
+      const uint8_t* ptrEnd = baseEnd;
+      while (ptr < ptrEnd) {
+        memcpy(dst, ptr + srcRowOffset, rowSize);
+        ptr += srcStride;
+        dst += dstStride;
+      }
+      basePtr += unpackImageHeight * srcStride;
+      baseEnd += unpackImageHeight * srcStride;
     }
     return true;
   }
 
-  FormatConverter converter(sourceDataSubRectangle, sourceData, destinationData,
-                            srcStride, srcRowOffset, dstStride);
+  FormatConverter converter(sourceDataSubRectangle, depth, unpackImageHeight,
+                            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