Revert "Revert "Compute (un-)premultiply_table at compile time""

This reverts commit c2374d702b0e4b7a1828964faa528344a5a9ee17, since
VS 2019 is now the baseline.

Change-Id: I3790ba3046910de2fffd7584a589c70cee56de0f
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/113569
Tested-by: Jenkins
Reviewed-by: Stephan Bergmann <sbergman@redhat.com>

1 files changed, 43 insertions, 22 deletions

diff --git a/vcl/source/bitmap/BitmapTools.cxx b/vcl/source/bitmap/BitmapTools.cxx
index 8bd24f1d5706..d963bb3bb85b 100644
--- a/vcl/source/bitmap/BitmapTools.cxx
+++ b/vcl/source/bitmap/BitmapTools.cxx
@@ -8,6 +8,11 @@
  *
  */
 
+#include <sal/config.h>
+
+#include <array>
+#include <utility>
+
 #include <vcl/BitmapTools.hxx>
 
 #include <sal/log.hxx>
@@ -284,7 +289,7 @@ BitmapEx* CreateFromCairoSurface(Size aSize, cairo_surface_t * pSurface)
     cairo_surface_flush(pPixels);
     unsigned char *pSrc = cairo_image_surface_get_data( pPixels );
     unsigned int nStride = cairo_image_surface_get_stride( pPixels );
-    vcl::bitmap::lookup_table unpremultiply_table = vcl::bitmap::get_unpremultiply_table();
+    vcl::bitmap::lookup_table const & unpremultiply_table = vcl::bitmap::get_unpremultiply_table();
     for( tools::Long y = 0; y < aSize.Height(); y++ )
     {
         sal_uInt32 *pPix = reinterpret_cast<sal_uInt32 *>(pSrc + nStride * y);
@@ -716,7 +721,7 @@ void CanvasCairoExtractBitmapData( BitmapEx const & aBmpEx, Bitmap & aBitmap, un
     ::Color aColor;
     unsigned int nAlpha = 255;
 
-    vcl::bitmap::lookup_table premultiply_table = vcl::bitmap::get_premultiply_table();
+    vcl::bitmap::lookup_table const & premultiply_table = vcl::bitmap::get_premultiply_table();
     for( nY = 0; nY < nHeight; nY++ )
     {
         ::Scanline pReadScan;
@@ -1037,43 +1042,59 @@ void CanvasCairoExtractBitmapData( BitmapEx const & aBmpEx, Bitmap & aBitmap, un
 
     sal_uInt8 unpremultiply(sal_uInt8 c, sal_uInt8 a)
     {
+        return get_unpremultiply_table()[a][c];
+    }
+
+    static constexpr sal_uInt8 unpremultiplyImpl(sal_uInt8 c, sal_uInt8 a)
+    {
         return (a == 0) ? 0 : (c * 255 + a / 2) / a;
     }
 
     sal_uInt8 premultiply(sal_uInt8 c, sal_uInt8 a)
     {
+        return get_premultiply_table()[a][c];
+    }
+
+    static constexpr sal_uInt8 premultiplyImpl(sal_uInt8 c, sal_uInt8 a)
+    {
         return (c * a + 127) / 255;
     }
 
-    lookup_table get_unpremultiply_table()
+    template<int... Is> static constexpr std::array<sal_uInt8, 256> make_unpremultiply_table_row_(
+        int a, std::integer_sequence<int, Is...>)
     {
-        static bool inited;
-        static sal_uInt8 unpremultiply_table[256][256];
+        return {unpremultiplyImpl(Is, a)...};
+    }
 
-        if (!inited)
-        {
-            for (int a = 0; a < 256; ++a)
-                for (int c = 0; c < 256; ++c)
-                    unpremultiply_table[a][c] = unpremultiply(c, a);
-            inited = true;
-        }
+    template<int... Is> static constexpr lookup_table make_unpremultiply_table_(
+        std::integer_sequence<int, Is...>)
+    {
+        return {make_unpremultiply_table_row_(Is, std::make_integer_sequence<int, 256>{})...};
+    }
 
+    lookup_table const & get_unpremultiply_table()
+    {
+        static constexpr auto unpremultiply_table = make_unpremultiply_table_(
+            std::make_integer_sequence<int, 256>{});
         return unpremultiply_table;
     }
 
-    lookup_table get_premultiply_table()
+    template<int... Is> static constexpr std::array<sal_uInt8, 256> make_premultiply_table_row_(
+        int a, std::integer_sequence<int, Is...>)
     {
-        static bool inited;
-        static sal_uInt8 premultiply_table[256][256];
+        return {premultiplyImpl(Is, a)...};
+    }
 
-        if (!inited)
-        {
-            for (int a = 0; a < 256; ++a)
-                for (int c = 0; c < 256; ++c)
-                    premultiply_table[a][c] = premultiply(c, a);
-            inited = true;
-        }
+    template<int... Is> static constexpr lookup_table make_premultiply_table_(
+        std::integer_sequence<int, Is...>)
+    {
+        return {make_premultiply_table_row_(Is, std::make_integer_sequence<int, 256>{})...};
+    }
 
+    lookup_table const & get_premultiply_table()
+    {
+        static constexpr auto premultiply_table = make_premultiply_table_(
+            std::make_integer_sequence<int, 256>{});
         return premultiply_table;
     }