Upgrade WebGLImageConversion to ES3: Part II.

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 "config.h"
 #include "platform/graphics/gpu/WebGLImageConversion.h"
 
 #include "platform/CheckedInt.h"
 #include "platform/graphics/ImageObserver.h"
 #include "platform/graphics/cpu/arm/WebGLImageConversionNEON.h"
@@ skipping 518 matching lines @@
     for (unsigned i = 0; i < pixelsPerRow; ++i) {
         destination[0] = source[0];
         destination[1] = source[0];
         destination[2] = source[0];
         destination[3] = source[1];
         source += 2;
         destination += 4;
     }
 }
 
+template<> void unpack<WebGLImageConversion::DataFormatRGBA2_10_10_10, uint32_t, uint16_t>(const uint32_t* source, uint16_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
 //----------------------------------------------------------------------
 // Pixel packing routines.
 //
 
 template<int format, int alphaOp, typename SourceType, typename DstType>
 void pack(const SourceType*, DstType*, unsigned)
 {
     ASSERT_NOT_REACHED();
 }
 
@@ skipping 108 matching lines @@
         uint8_t sourceG = static_cast<uint8_t>(static_cast<float>(source[1]) * scaleFactor);
         uint8_t sourceB = static_cast<uint8_t>(static_cast<float>(source[2]) * scaleFactor);
         destination[0] = sourceR;
         destination[1] = sourceG;
         destination[2] = sourceB;
         source += 4;
         destination += 3;
     }
 }
 
-
-template<> void pack<WebGLImageConversion::DataFormatRGBA8, WebGLImageConversion::AlphaDoNothing, uint8_t, uint8_t>(const uint8_t* source, uint8_t* destination, unsigned pixelsPerRow)
-{
-    memcpy(destination, source, pixelsPerRow * 4);
-}
-
 template<> void pack<WebGLImageConversion::DataFormatRGBA8, WebGLImageConversion::AlphaDoPremultiply, uint8_t, uint8_t>(const uint8_t* source, uint8_t* destination, unsigned pixelsPerRow)
 {
     for (unsigned i = 0; i < pixelsPerRow; ++i) {
         float scaleFactor = source[3] / 255.0f;
         uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor);
         uint8_t sourceG = static_cast<uint8_t>(static_cast<float>(source[1]) * scaleFactor);
         uint8_t sourceB = static_cast<uint8_t>(static_cast<float>(source[2]) * scaleFactor);
         destination[0] = sourceR;
         destination[1] = sourceG;
         destination[2] = sourceB;
@@ skipping 189 matching lines @@
     for (unsigned i = 0; i < pixelsPerRow; ++i) {
         float scaleFactor = source[3] ? 1.0f / source[3] : 1.0f;
         destination[0] = source[0] * scaleFactor;
         destination[1] = source[1] * scaleFactor;
         destination[2] = source[2] * scaleFactor;
         source += 4;
         destination += 3;
     }
 }
 
-// Used only during RGBA8 or BGRA8 -> floating-point uploads.
-template<> void pack<WebGLImageConversion::DataFormatRGBA32F, WebGLImageConversion::AlphaDoNothing, float, float>(const float* source, float* destination, unsigned pixelsPerRow)
-{
-    memcpy(destination, source, pixelsPerRow * 4 * sizeof(float));
-}
-
 template<> void pack<WebGLImageConversion::DataFormatRGBA32F, WebGLImageConversion::AlphaDoPremultiply, float, float>(const float* source, float* destination, unsigned pixelsPerRow)
 {
     for (unsigned i = 0; i < pixelsPerRow; ++i) {
         float scaleFactor = source[3];
         destination[0] = source[0] * scaleFactor;
         destination[1] = source[1] * scaleFactor;
         destination[2] = source[2] * scaleFactor;
         destination[3] = source[3];
         source += 4;
         destination += 4;
@@ skipping 219 matching lines @@
 
 template<> void pack<WebGLImageConversion::DataFormatA16F, WebGLImageConversion::AlphaDoNothing, float, uint16_t>(const float* source, uint16_t* destination, unsigned pixelsPerRow)
 {
     for (unsigned i = 0; i < pixelsPerRow; ++i) {
         destination[0] = convertFloatToHalfFloat(source[3]);
         source += 4;
         destination += 1;
     }
 }
 
+template<> void pack<WebGLImageConversion::DataFormatRGBA8_S, WebGLImageConversion::AlphaDoPremultiply, int8_t, int8_t>(const int8_t* source, int8_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+// FIXME: this routine is lossy and must be removed.
+template<> void pack<WebGLImageConversion::DataFormatRGBA8_S, WebGLImageConversion::AlphaDoUnmultiply, int8_t, int8_t>(const int8_t* source, int8_t* destination, unsigned pixelsPerRow)

[Ken Russell (switch to Gerrit), 2015/06/20 02:42:23]

The only situation where un-multiplication is needed is when uploading data from
a canvas element, where the color data is stored in premultiplied form. Per our
offline discussion, we were talking about not supporting uploading HTML elements
to the signed texture formats, among others. Does this mean that this pack
template (and its caller) can be removed? Same basic question for all of the new
AlphaDoUnmultiply variants here.

Basically, I wonder whether the use of FORMATCONVERTER_CASE_DSTFORMAT can be
broken up in the "convert" template function below to handle
AlphaDoPremultiply/AlphaDoNothing separately from AlphaDoUnmultiply, which
should be much more rare, and thereby reduce the size of the code.

[Zhenyao Mo, 2015/06/23 19:12:00]

Agree.  Will revise in a followup.

+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+template<> void pack<WebGLImageConversion::DataFormatRGBA16, WebGLImageConversion::AlphaDoPremultiply, uint16_t, uint16_t>(const uint16_t* source, uint16_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+// FIXME: this routine is lossy and must be removed.
+template<> void pack<WebGLImageConversion::DataFormatRGBA16, WebGLImageConversion::AlphaDoUnmultiply, uint16_t, uint16_t>(const uint16_t* source, uint16_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+template<> void pack<WebGLImageConversion::DataFormatRGBA16_S, WebGLImageConversion::AlphaDoPremultiply, int16_t, int16_t>(const int16_t* source, int16_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+// FIXME: this routine is lossy and must be removed.
+template<> void pack<WebGLImageConversion::DataFormatRGBA16_S, WebGLImageConversion::AlphaDoUnmultiply, int16_t, int16_t>(const int16_t* source, int16_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+template<> void pack<WebGLImageConversion::DataFormatRGBA32, WebGLImageConversion::AlphaDoPremultiply, uint32_t, uint32_t>(const uint32_t* source, uint32_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+// FIXME: this routine is lossy and must be removed.
+template<> void pack<WebGLImageConversion::DataFormatRGBA32, WebGLImageConversion::AlphaDoUnmultiply, uint32_t, uint32_t>(const uint32_t* source, uint32_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+template<> void pack<WebGLImageConversion::DataFormatRGBA32_S, WebGLImageConversion::AlphaDoPremultiply, int32_t, int32_t>(const int32_t* source, int32_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+// FIXME: this routine is lossy and must be removed.
+template<> void pack<WebGLImageConversion::DataFormatRGBA32_S, WebGLImageConversion::AlphaDoUnmultiply, int32_t, int32_t>(const int32_t* source, int32_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+template<> void pack<WebGLImageConversion::DataFormatRGBA2_10_10_10, WebGLImageConversion::AlphaDoPremultiply, uint16_t, uint32_t>(const uint16_t* source, uint32_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+// FIXME: this routine is lossy and must be removed.
+template<> void pack<WebGLImageConversion::DataFormatRGBA2_10_10_10, WebGLImageConversion::AlphaDoUnmultiply, uint16_t, uint32_t>(const uint16_t* source, uint32_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+template<> void pack<WebGLImageConversion::DataFormatRGB10F11F11F, WebGLImageConversion::AlphaDoNothing, float, uint32_t>(const float* source, uint32_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+template<> void pack<WebGLImageConversion::DataFormatRGB10F11F11F, WebGLImageConversion::AlphaDoPremultiply, float, uint32_t>(const float* source, uint32_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+// FIXME: this routine is lossy and must be removed.
+template<> void pack<WebGLImageConversion::DataFormatRGB10F11F11F, WebGLImageConversion::AlphaDoUnmultiply, float, uint32_t>(const float* source, uint32_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+template<> void pack<WebGLImageConversion::DataFormatRG8, WebGLImageConversion::AlphaDoNothing, uint8_t, uint8_t>(const uint8_t* source, uint8_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+template<> void pack<WebGLImageConversion::DataFormatRG8, WebGLImageConversion::AlphaDoPremultiply, uint8_t, uint8_t>(const uint8_t* source, uint8_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+// FIXME: this routine is lossy and must be removed.
+template<> void pack<WebGLImageConversion::DataFormatRG8, WebGLImageConversion::AlphaDoUnmultiply, uint8_t, uint8_t>(const uint8_t* source, uint8_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+template<> void pack<WebGLImageConversion::DataFormatRG16F, WebGLImageConversion::AlphaDoNothing, float, uint16_t>(const float* source, uint16_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+template<> void pack<WebGLImageConversion::DataFormatRG16F, WebGLImageConversion::AlphaDoPremultiply, float, uint16_t>(const float* source, uint16_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+// FIXME: this routine is lossy and must be removed.
+template<> void pack<WebGLImageConversion::DataFormatRG16F, WebGLImageConversion::AlphaDoUnmultiply, float, uint16_t>(const float* source, uint16_t* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+template<> void pack<WebGLImageConversion::DataFormatRG32F, WebGLImageConversion::AlphaDoNothing, float, float>(const float* source, float* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+template<> void pack<WebGLImageConversion::DataFormatRG32F, WebGLImageConversion::AlphaDoPremultiply, float, float>(const float* source, float* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
+// FIXME: this routine is lossy and must be removed.
+template<> void pack<WebGLImageConversion::DataFormatRG32F, WebGLImageConversion::AlphaDoUnmultiply, float, float>(const float* source, float* destination, unsigned pixelsPerRow)
+{
+    // FIXME: Implement this.
+    ASSERT_NOT_REACHED();
+}
+
 bool HasAlpha(int format)
 {
     return format == WebGLImageConversion::DataFormatA8
         || format == WebGLImageConversion::DataFormatA16F
         || format == WebGLImageConversion::DataFormatA32F
         || format == WebGLImageConversion::DataFormatRA8
         || format == WebGLImageConversion::DataFormatAR8
         || format == WebGLImageConversion::DataFormatRA16F
         || format == WebGLImageConversion::DataFormatRA32F
         || format == WebGLImageConversion::DataFormatRGBA8
@@ skipping 359 matching lines @@
             FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatRA8)
             FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatRA32F)
             FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatRGBA8)
             FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatARGB8)
             FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatABGR8)
             FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatAR8)
             FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatBGRA8)
             FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatRGBA5551)
             FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatRGBA4444)
             FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatRGBA32F)
+            FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatRGBA2_10_10_10)
         default:
             ASSERT_NOT_REACHED();
         }
 #undef FORMATCONVERTER_CASE_SRCFORMAT
 }
 
 template<WebGLImageConversion::DataFormat SrcFormat>
 void FormatConverter::convert(WebGLImageConversion::DataFormat dstFormat, WebGLImageConversion::AlphaOp alphaOp)
 {
 #define FORMATCONVERTER_CASE_DSTFORMAT(DstFormat) \
@@ skipping 12 matching lines @@
             FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRA32F)
             FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGB8)
             FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGB565)
             FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGB16F)
             FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGB32F)
             FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA8)
             FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA5551)
             FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA4444)
             FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA16F)
             FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA32F)
+            FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA8_S)
+            FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA16)
+            FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA16_S)
+            FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA32)
+            FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA32_S)
+            FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA2_10_10_10)
+            FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGB10F11F11F)
+            FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRG8)
+            FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRG16F)
+            FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRG32F)
         default:
             ASSERT_NOT_REACHED();
         }
 
 #undef FORMATCONVERTER_CASE_DSTFORMAT
 }
 
 template<WebGLImageConversion::DataFormat SrcFormat, WebGLImageConversion::DataFormat DstFormat>
 void FormatConverter::convert(WebGLImageConversion::AlphaOp alphaOp)
 {
@@ skipping 41 matching lines @@
         return;
     }
 
     typedef typename DataTypeForFormat<SrcFormat>::Type SrcType;
     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 && m_dstStride > 0;
+    const bool trivialPack = DstFormat == IntermFormat && alphaOp == WebGLImageConversion::AlphaDoNothing;
     ASSERT(!trivialUnpack || !trivialPack);
 
     const SrcType *srcRowStart = static_cast<const SrcType*>(m_srcStart);
     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);
             srcRowStart += srcStrideInElements;
             dstRowStart += dstStrideInElements;
         }
@@ skipping 381 matching lines @@
     void* destinationData,
     bool flipY)
 {
     int validSrc = width * TexelBytesForFormat(sourceDataFormat);
     int remainder = sourceUnpackAlignment ? (validSrc % sourceUnpackAlignment) : 0;
     int srcStride = remainder ? (validSrc + sourceUnpackAlignment - remainder) : validSrc;
 
     DataFormat dstDataFormat = getDataFormat(destinationFormat, destinationType);
     int dstStride = width * TexelBytesForFormat(dstDataFormat);
     if (flipY) {
-        destinationData = static_cast<uint8_t*>(destinationData) + dstStride*(height - 1);
+        destinationData = static_cast<uint8_t*>(destinationData) + dstStride * (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;
         unsigned rowSize = (dstStride > 0) ? dstStride: -dstStride;
         uint8_t* dst = static_cast<uint8_t*>(destinationData);
         while (ptr < ptrEnd) {
             memcpy(dst, ptr, rowSize);
             ptr += srcStride;
             dst += dstStride;
         }
         return true;
     }
 
     FormatConverter converter(width, height, sourceData, destinationData, srcStride, dstStride);
     converter.convert(sourceDataFormat, dstDataFormat, alphaOp);
     if (!converter.Success())
         return false;
     return true;
 }
 
 } // namespace blink