Add m-esr52 at 52.6.0

1 files changed, 435 insertions, 0 deletions

diff --git a/dom/canvas/WebGLTexelConversions.cpp b/dom/canvas/WebGLTexelConversions.cpp
new file mode 100644
index 000000000..f6ffe0cae
--- /dev/null
+++ b/dom/canvas/WebGLTexelConversions.cpp
@@ -0,0 +1,435 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WebGLContext.h"
+#include "WebGLTexelConversions.h"
+
+namespace mozilla {
+
+using namespace WebGLTexelConversions;
+
+namespace {
+
+/** @class WebGLImageConverter
+ *
+ * This class is just a helper to implement WebGLContext::ConvertImage below.
+ *
+ * Design comments:
+ *
+ * WebGLContext::ConvertImage has to handle hundreds of format conversion paths.
+ * It is important to minimize executable code size here. Instead of passing around
+ * a large number of function parameters hundreds of times, we create a
+ * WebGLImageConverter object once, storing these parameters, and then we call
+ * the run() method on it.
+ */
+class WebGLImageConverter
+{
+    const size_t mWidth, mHeight;
+    const void* const mSrcStart;
+    void* const mDstStart;
+    const ptrdiff_t mSrcStride, mDstStride;
+    bool mAlreadyRun;
+    bool mSuccess;
+
+    /*
+     * Returns sizeof(texel)/sizeof(type). The point is that we will iterate over
+     * texels with typed pointers and this value will tell us by how much we need
+     * to increment these pointers to advance to the next texel.
+     */
+    template<WebGLTexelFormat Format>
+    static size_t NumElementsPerTexelForFormat() {
+        switch (Format) {
+            case WebGLTexelFormat::A8:
+            case WebGLTexelFormat::A16F:
+            case WebGLTexelFormat::A32F:
+            case WebGLTexelFormat::R8:
+            case WebGLTexelFormat::R16F:
+            case WebGLTexelFormat::R32F:
+            case WebGLTexelFormat::RGB565:
+            case WebGLTexelFormat::RGB11F11F10F:
+            case WebGLTexelFormat::RGBA4444:
+            case WebGLTexelFormat::RGBA5551:
+                return 1;
+            case WebGLTexelFormat::RA8:
+            case WebGLTexelFormat::RA16F:
+            case WebGLTexelFormat::RA32F:
+            case WebGLTexelFormat::RG8:
+            case WebGLTexelFormat::RG16F:
+            case WebGLTexelFormat::RG32F:
+                return 2;
+            case WebGLTexelFormat::RGB8:
+            case WebGLTexelFormat::RGB16F:
+            case WebGLTexelFormat::RGB32F:
+                return 3;
+            case WebGLTexelFormat::RGBA8:
+            case WebGLTexelFormat::RGBA16F:
+            case WebGLTexelFormat::RGBA32F:
+            case WebGLTexelFormat::BGRX8:
+            case WebGLTexelFormat::BGRA8:
+                return 4;
+            default:
+                MOZ_ASSERT(false, "Unknown texel format. Coding mistake?");
+                return 0;
+        }
+    }
+
+    /*
+     * This is the completely format-specific templatized conversion function,
+     * that will be instantiated hundreds of times for all different combinations.
+     * It is important to avoid generating useless code here. In particular, many
+     * instantiations of this function template will never be called, so we try
+     * to return immediately in these cases to allow the compiler to avoid generating
+     * useless code.
+     */
+    template<WebGLTexelFormat SrcFormat,
+             WebGLTexelFormat DstFormat,
+             WebGLTexelPremultiplicationOp PremultiplicationOp>
+    void run()
+    {
+        // check for never-called cases. We early-return to allow the compiler
+        // to avoid generating this code. It would be tempting to abort() instead,
+        // as returning early does leave the destination surface with uninitialized
+        // data, but that would not allow the compiler to avoid generating this code.
+        // So instead, we return early, so Success() will return false, and the caller
+        // must check that and abort in that case. See WebGLContext::ConvertImage.
+
+        if (SrcFormat == DstFormat &&
+            PremultiplicationOp == WebGLTexelPremultiplicationOp::None)
+        {
+            // Should have used a fast exit path earlier, rather than entering this function.
+            // we explicitly return here to allow the compiler to avoid generating this code
+            return;
+        }
+
+        // Only textures uploaded from DOM elements or ImageData can allow DstFormat != SrcFormat.
+        // DOM elements can only give BGRA8, BGRX8, A8, RGB565 formats. See DOMElementToImageSurface.
+        // ImageData is always RGBA8. So all other SrcFormat will always satisfy DstFormat==SrcFormat,
+        // so we can avoid compiling the code for all the unreachable paths.
+        const bool CanSrcFormatComeFromDOMElementOrImageData
+            = SrcFormat == WebGLTexelFormat::BGRA8 ||
+              SrcFormat == WebGLTexelFormat::BGRX8 ||
+              SrcFormat == WebGLTexelFormat::A8 ||
+              SrcFormat == WebGLTexelFormat::RGB565 ||
+              SrcFormat == WebGLTexelFormat::RGBA8;
+        if (!CanSrcFormatComeFromDOMElementOrImageData &&
+            SrcFormat != DstFormat)
+        {
+            return;
+        }
+
+        // Likewise, only textures uploaded from DOM elements or ImageData can possibly have to be unpremultiplied.
+        if (!CanSrcFormatComeFromDOMElementOrImageData &&
+            PremultiplicationOp == WebGLTexelPremultiplicationOp::Unpremultiply)
+        {
+            return;
+        }
+
+        // there is no point in premultiplication/unpremultiplication
+        // in the following cases:
+        //  - the source format has no alpha
+        //  - the source format has no color
+        //  - the destination format has no color
+        if (!HasAlpha(SrcFormat) ||
+            !HasColor(SrcFormat) ||
+            !HasColor(DstFormat))
+        {
+
+            if (PremultiplicationOp != WebGLTexelPremultiplicationOp::None)
+            {
+                return;
+            }
+        }
+
+        // end of early return cases.
+
+        MOZ_ASSERT(!mAlreadyRun, "converter should be run only once!");
+        mAlreadyRun = true;
+
+        // gather some compile-time meta-data about the formats at hand.
+
+        typedef
+            typename DataTypeForFormat<SrcFormat>::Type
+            SrcType;
+        typedef
+            typename DataTypeForFormat<DstFormat>::Type
+            DstType;
+
+        const WebGLTexelFormat IntermediateSrcFormat
+            = IntermediateFormat<SrcFormat>::Value;
+        const WebGLTexelFormat IntermediateDstFormat
+            = IntermediateFormat<DstFormat>::Value;
+        typedef
+            typename DataTypeForFormat<IntermediateSrcFormat>::Type
+            IntermediateSrcType;
+        typedef
+            typename DataTypeForFormat<IntermediateDstFormat>::Type
+            IntermediateDstType;
+
+        const size_t NumElementsPerSrcTexel = NumElementsPerTexelForFormat<SrcFormat>();
+        const size_t NumElementsPerDstTexel = NumElementsPerTexelForFormat<DstFormat>();
+        const size_t MaxElementsPerTexel = 4;
+        MOZ_ASSERT(NumElementsPerSrcTexel <= MaxElementsPerTexel, "unhandled format");
+        MOZ_ASSERT(NumElementsPerDstTexel <= MaxElementsPerTexel, "unhandled format");
+
+        // we assume that the strides are multiples of the sizeof of respective types.
+        // this assumption will allow us to iterate over src and dst images using typed
+        // pointers, e.g. uint8_t* or uint16_t* or float*, instead of untyped pointers.
+        // So this assumption allows us to write cleaner and safer code, but it might
+        // not be true forever and if it eventually becomes wrong, we'll have to revert
+        // to always iterating using uint8_t* pointers regardless of the types at hand.
+        MOZ_ASSERT(mSrcStride % sizeof(SrcType) == 0 &&
+                   mDstStride % sizeof(DstType) == 0,
+                   "Unsupported: texture stride is not a multiple of sizeof(type)");
+        const ptrdiff_t srcStrideInElements = mSrcStride / sizeof(SrcType);
+        const ptrdiff_t dstStrideInElements = mDstStride / sizeof(DstType);
+
+        const SrcType* srcRowStart = static_cast<const SrcType*>(mSrcStart);
+        DstType* dstRowStart = static_cast<DstType*>(mDstStart);
+
+        // the loop performing the texture format conversion
+        for (size_t i = 0; i < mHeight; ++i) {
+            const SrcType* srcRowEnd = srcRowStart + mWidth * NumElementsPerSrcTexel;
+            const SrcType* srcPtr = srcRowStart;
+            DstType* dstPtr = dstRowStart;
+            while (srcPtr != srcRowEnd) {
+                // convert a single texel. We proceed in 3 steps: unpack the source texel
+                // so the corresponding interchange format (e.g. unpack RGB565 to RGBA8),
+                // convert the resulting data type to the destination type (e.g. convert
+                // from RGBA8 to RGBA32F), and finally pack the destination texel
+                // (e.g. pack RGBA32F to RGB32F).
+                IntermediateSrcType unpackedSrc[MaxElementsPerTexel];
+                IntermediateDstType unpackedDst[MaxElementsPerTexel];
+
+                // unpack a src texel to corresponding intermediate src format.
+                // for example, unpack RGB565 to RGBA8
+                unpack<SrcFormat>(srcPtr, unpackedSrc);
+                // convert the data type to the destination type, if needed.
+                // for example, convert RGBA8 to RGBA32F
+                convertType(unpackedSrc, unpackedDst);
+                // pack the destination texel.
+                // for example, pack RGBA32F to RGB32F
+                pack<DstFormat, PremultiplicationOp>(unpackedDst, dstPtr);
+
+                srcPtr += NumElementsPerSrcTexel;
+                dstPtr += NumElementsPerDstTexel;
+            }
+            srcRowStart += srcStrideInElements;
+            dstRowStart += dstStrideInElements;
+        }
+
+        mSuccess = true;
+        return;
+    }
+
+    template<WebGLTexelFormat SrcFormat,
+             WebGLTexelFormat DstFormat>
+    void run(WebGLTexelPremultiplicationOp premultiplicationOp)
+    {
+        #define WEBGLIMAGECONVERTER_CASE_PREMULTIPLICATIONOP(PremultiplicationOp) \
+            case PremultiplicationOp: \
+                return run<SrcFormat, DstFormat, PremultiplicationOp>();
+
+        switch (premultiplicationOp) {
+            WEBGLIMAGECONVERTER_CASE_PREMULTIPLICATIONOP(WebGLTexelPremultiplicationOp::None)
+            WEBGLIMAGECONVERTER_CASE_PREMULTIPLICATIONOP(WebGLTexelPremultiplicationOp::Premultiply)
+            WEBGLIMAGECONVERTER_CASE_PREMULTIPLICATIONOP(WebGLTexelPremultiplicationOp::Unpremultiply)
+            default:
+                MOZ_ASSERT(false, "unhandled case. Coding mistake?");
+        }
+
+        #undef WEBGLIMAGECONVERTER_CASE_PREMULTIPLICATIONOP
+    }
+
+    template<WebGLTexelFormat SrcFormat>
+    void run(WebGLTexelFormat dstFormat,
+             WebGLTexelPremultiplicationOp premultiplicationOp)
+    {
+        #define WEBGLIMAGECONVERTER_CASE_DSTFORMAT(DstFormat) \
+            case DstFormat: \
+                return run<SrcFormat, DstFormat>(premultiplicationOp);
+
+        switch (dstFormat) {
+        // 1-channel formats
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::A8)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::A16F)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::A32F)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::R8)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::R16F)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::R32F)
+        // 2-channel formats
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RA8)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RA16F)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RA32F)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RG8)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RG16F)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RG32F)
+        // 3-channel formats
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RGB565)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RGB8)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RGB11F11F10F)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RGB16F)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RGB32F)
+        // 4-channel formats
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RGBA4444)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RGBA5551)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RGBA8)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RGBA16F)
+        WEBGLIMAGECONVERTER_CASE_DSTFORMAT(WebGLTexelFormat::RGBA32F)
+
+        default:
+            MOZ_ASSERT(false, "unhandled case. Coding mistake?");
+        }
+
+        #undef WEBGLIMAGECONVERTER_CASE_DSTFORMAT
+    }
+
+public:
+
+    void run(WebGLTexelFormat srcFormat,
+             WebGLTexelFormat dstFormat,
+             WebGLTexelPremultiplicationOp premultiplicationOp)
+    {
+        #define WEBGLIMAGECONVERTER_CASE_SRCFORMAT(SrcFormat) \
+            case SrcFormat: \
+                return run<SrcFormat>(dstFormat, premultiplicationOp);
+
+        switch (srcFormat) {
+        // 1-channel formats
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::A8)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::A16F)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::A32F)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::R8)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::R16F)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::R32F)
+        // 2-channel formats
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::RA8)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::RA16F)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::RA32F)
+        // 3-channel formats
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::RGB565)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::RGB8)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::RGB16F)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::RGB32F)
+        // 4-channel formats
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::RGBA4444)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::RGBA5551)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::RGBA8)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::RGBA16F)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::RGBA32F)
+        // DOM element source formats
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::BGRX8)
+        WEBGLIMAGECONVERTER_CASE_SRCFORMAT(WebGLTexelFormat::BGRA8)
+
+        default:
+            MOZ_ASSERT(false, "unhandled case. Coding mistake?");
+        }
+
+        #undef WEBGLIMAGECONVERTER_CASE_SRCFORMAT
+    }
+
+    WebGLImageConverter(size_t width, size_t height,
+                        const void* srcStart, void* dstStart,
+                        ptrdiff_t srcStride, ptrdiff_t dstStride)
+        : mWidth(width), mHeight(height),
+          mSrcStart(srcStart), mDstStart(dstStart),
+          mSrcStride(srcStride), mDstStride(dstStride),
+          mAlreadyRun(false), mSuccess(false)
+    {}
+
+    bool Success() const {
+        return mSuccess;
+    }
+};
+
+} // end anonymous namespace
+
+bool
+ConvertImage(size_t width, size_t height,
+             const void* srcBegin, size_t srcStride, gl::OriginPos srcOrigin,
+             WebGLTexelFormat srcFormat, bool srcPremultiplied,
+             void* dstBegin, size_t dstStride, gl::OriginPos dstOrigin,
+             WebGLTexelFormat dstFormat, bool dstPremultiplied,
+             bool* const out_wasTrivial)
+{
+    *out_wasTrivial = true;
+
+    if (srcFormat == WebGLTexelFormat::FormatNotSupportingAnyConversion ||
+        dstFormat == WebGLTexelFormat::FormatNotSupportingAnyConversion)
+    {
+        return false;
+    }
+
+    if (!width || !height)
+        return true;
+
+    const bool shouldYFlip = (srcOrigin != dstOrigin);
+
+    const bool canSkipPremult = (!HasAlpha(srcFormat) ||
+                                 !HasColor(srcFormat) ||
+                                 !HasColor(dstFormat));
+
+    WebGLTexelPremultiplicationOp premultOp;
+    if (canSkipPremult) {
+        premultOp = WebGLTexelPremultiplicationOp::None;
+    } else if (!srcPremultiplied && dstPremultiplied) {
+        premultOp = WebGLTexelPremultiplicationOp::Premultiply;
+    } else if (srcPremultiplied && !dstPremultiplied) {
+        premultOp = WebGLTexelPremultiplicationOp::Unpremultiply;
+    } else {
+        premultOp = WebGLTexelPremultiplicationOp::None;
+    }
+
+    const uint8_t* srcItr = (const uint8_t*)srcBegin;
+    const uint8_t* const srcEnd = srcItr + srcStride * height;
+    uint8_t* dstItr = (uint8_t*)dstBegin;
+    ptrdiff_t dstItrStride = dstStride;
+    if (shouldYFlip) {
+         dstItr = dstItr + dstStride * (height - 1);
+         dstItrStride = -dstItrStride;
+    }
+
+    if (srcFormat == dstFormat && premultOp == WebGLTexelPremultiplicationOp::None) {
+        // Fast exit path: we just have to memcpy all the rows.
+        //
+        // The case where absolutely nothing needs to be done is supposed to have
+        // been handled earlier (in TexImage2D_base, etc).
+        //
+        // So the case we're handling here is when even though no format conversion is
+        // needed, we still might have to flip vertically and/or to adjust to a different
+        // stride.
+
+        // We ignore canSkipPremult for this perf trap, since it's an avoidable perf cliff
+        // under the WebGL API user's control.
+        MOZ_ASSERT((srcPremultiplied != dstPremultiplied ||
+                    shouldYFlip ||
+                    srcStride != dstStride),
+                   "Performance trap -- should handle this case earlier to avoid memcpy");
+
+        const auto bytesPerPixel = TexelBytesForFormat(srcFormat);
+        const size_t bytesPerRow = bytesPerPixel * width;
+
+        while (srcItr != srcEnd) {
+            memcpy(dstItr, srcItr, bytesPerRow);
+            srcItr += srcStride;
+            dstItr += dstItrStride;
+        }
+        return true;
+    }
+
+    *out_wasTrivial = false;
+
+    WebGLImageConverter converter(width, height, srcItr, dstItr, srcStride, dstItrStride);
+    converter.run(srcFormat, dstFormat, premultOp);
+
+    if (!converter.Success()) {
+        // the dst image may be left uninitialized, so we better not try to
+        // continue even in release builds. This should never happen anyway,
+        // and would be a bug in our code.
+        NS_RUNTIMEABORT("programming mistake in WebGL texture conversions");
+    }
+
+    return true;
+}
+
+} // end namespace mozilla