Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

45 files changed, 16853 insertions, 0 deletions

diff --git a/vcl/source/bitmap/BitmapAlphaClampFilter.cxx b/vcl/source/bitmap/BitmapAlphaClampFilter.cxx
new file mode 100644
index 0000000000..d36261b2eb
--- /dev/null
+++ b/vcl/source/bitmap/BitmapAlphaClampFilter.cxx
@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <vcl/bitmapex.hxx>
+#include <vcl/BitmapAlphaClampFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+BitmapEx BitmapAlphaClampFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    if (!rBitmapEx.IsAlpha())
+        return rBitmapEx;
+
+    AlphaMask aBitmapAlpha(rBitmapEx.GetAlphaMask());
+    {
+        BitmapScopedWriteAccess pWriteAlpha(aBitmapAlpha);
+        const Size aSize(rBitmapEx.GetSizePixel());
+
+        for (sal_Int32 nY = 0; nY < sal_Int32(aSize.Height()); ++nY)
+        {
+            Scanline pScanAlpha = pWriteAlpha->GetScanline(nY);
+
+            for (sal_Int32 nX = 0; nX < sal_Int32(aSize.Width()); ++nX)
+            {
+                BitmapColor aBitmapAlphaValue(pWriteAlpha->GetPixelFromData(pScanAlpha, nX));
+                if ((255 - aBitmapAlphaValue.GetIndex()) > mcThreshold)
+                {
+                    aBitmapAlphaValue.SetIndex(0);
+                    pWriteAlpha->SetPixelOnData(pScanAlpha, nX, aBitmapAlphaValue);
+                }
+            }
+        }
+    }
+
+    return BitmapEx(rBitmapEx.GetBitmap(), aBitmapAlpha);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapBasicMorphologyFilter.cxx b/vcl/source/bitmap/BitmapBasicMorphologyFilter.cxx
new file mode 100644
index 0000000000..e4285cb53a
--- /dev/null
+++ b/vcl/source/bitmap/BitmapBasicMorphologyFilter.cxx
@@ -0,0 +1,370 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <sal/config.h>
+
+#include <comphelper/threadpool.hxx>
+#include <sal/log.hxx>
+#include <vcl/BitmapBasicMorphologyFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+#include <algorithm>
+
+/* TODO: Use round kernel instead of square one.
+   This would make the result more natural, e.g. not making rounded square out of circle.
+ */
+
+namespace
+{
+struct FilterSharedData
+{
+    BitmapScopedReadAccess& mpReadAccess;
+    BitmapScopedWriteAccess& mpWriteAccess;
+    sal_Int32 mnRadius;
+    sal_uInt8 mnOutsideVal;
+    Color maOutsideColor;
+
+    FilterSharedData(BitmapScopedReadAccess& rReadAccess, BitmapScopedWriteAccess& rWriteAccess,
+                     sal_Int32 nRadius, sal_uInt8 nOutsideVal)
+        : mpReadAccess(rReadAccess)
+        , mpWriteAccess(rWriteAccess)
+        , mnRadius(nRadius)
+        , mnOutsideVal(nOutsideVal)
+        , maOutsideColor(ColorTransparency, nOutsideVal, nOutsideVal, nOutsideVal, nOutsideVal)
+    {
+    }
+};
+
+// Black is foreground, white is background
+
+struct ErodeOp
+{
+    static sal_uInt8 apply(sal_uInt8 v1, sal_uInt8 v2) { return std::max(v1, v2); }
+    static constexpr sal_uInt8 initVal = 0;
+};
+
+struct DilateOp
+{
+    static sal_uInt8 apply(sal_uInt8 v1, sal_uInt8 v2) { return std::min(v1, v2); }
+    static constexpr sal_uInt8 initVal = SAL_MAX_UINT8;
+};
+
+// 8 bit per channel case
+
+template <typename MorphologyOp, int nComponentWidth> struct Value
+{
+    static constexpr int nWidthBytes = nComponentWidth / 8;
+    static_assert(nWidthBytes * 8 == nComponentWidth);
+
+    sal_uInt8 aResult[nWidthBytes];
+
+    // If we are at the start or at the end of the line, consider outside value
+    Value(FilterSharedData const& rShared, bool bLookOutside)
+    {
+        std::fill_n(aResult, nWidthBytes,
+                    bLookOutside ? rShared.mnOutsideVal : MorphologyOp::initVal);
+    }
+
+    void apply(BitmapScopedReadAccess& pReadAccess, sal_Int32 x, sal_Int32 y,
+               sal_uInt8* pHint = nullptr)
+    {
+        sal_uInt8* pSource = (pHint ? pHint : pReadAccess->GetScanline(y)) + nWidthBytes * x;
+        std::transform(pSource, pSource + nWidthBytes, aResult, aResult, MorphologyOp::apply);
+    }
+
+    void copy(BitmapScopedWriteAccess& pWriteAccess, sal_Int32 x, sal_Int32 y,
+              sal_uInt8* pHint = nullptr)
+    {
+        sal_uInt8* pDest = (pHint ? pHint : pWriteAccess->GetScanline(y)) + nWidthBytes * x;
+        std::copy_n(aResult, nWidthBytes, pDest);
+    }
+};
+
+// Partial specializations for nComponentWidth == 0, using access' GetColor/SetPixel
+
+template <typename MorphologyOp> struct Value<MorphologyOp, 0>
+{
+    static constexpr Color initColor{ ColorTransparency, MorphologyOp::initVal,
+                                      MorphologyOp::initVal, MorphologyOp::initVal,
+                                      MorphologyOp::initVal };
+
+    Color aResult;
+
+    // If we are at the start or at the end of the line, consider outside value
+    Value(FilterSharedData const& rShared, bool bLookOutside)
+        : aResult(bLookOutside ? rShared.maOutsideColor : initColor)
+    {
+    }
+
+    void apply(const BitmapScopedReadAccess& pReadAccess, sal_Int32 x, sal_Int32 y,
+               sal_uInt8* /*pHint*/ = nullptr)
+    {
+        const auto& rSource = pReadAccess->GetColor(y, x);
+        aResult = Color(ColorAlpha, MorphologyOp::apply(rSource.GetAlpha(), aResult.GetAlpha()),
+                        MorphologyOp::apply(rSource.GetRed(), aResult.GetRed()),
+                        MorphologyOp::apply(rSource.GetGreen(), aResult.GetGreen()),
+                        MorphologyOp::apply(rSource.GetBlue(), aResult.GetBlue()));
+    }
+
+    void copy(BitmapScopedWriteAccess& pWriteAccess, sal_Int32 x, sal_Int32 y,
+              sal_uInt8* /*pHint*/ = nullptr)
+    {
+        pWriteAccess->SetPixel(y, x, aResult);
+    }
+};
+
+bool GetMinMax(sal_Int32 nCenter, sal_Int32 nRadius, sal_Int32 nMaxLimit, sal_Int32& nMin,
+               sal_Int32& nMax)
+{
+    nMin = nCenter - nRadius;
+    nMax = nCenter + nRadius;
+    bool bLookOutside = false;
+    if (nMin < 0)
+    {
+        bLookOutside = true;
+        nMin = 0;
+    }
+    if (nMax > nMaxLimit)
+    {
+        bLookOutside = true;
+        nMax = nMaxLimit;
+    }
+    return bLookOutside;
+}
+
+template <typename MorphologyOp, int nComponentWidth> struct pass
+{
+    static void Horizontal(FilterSharedData const& rShared, const sal_Int32 nStart,
+                           const sal_Int32 nEnd)
+    {
+        BitmapScopedReadAccess& pReadAccess = rShared.mpReadAccess;
+        BitmapScopedWriteAccess& pWriteAccess = rShared.mpWriteAccess;
+
+        const sal_Int32 nLastIndex = pReadAccess->Width() - 1;
+
+        for (sal_Int32 y = nStart; y <= nEnd; y++)
+        {
+            // Optimization
+            sal_uInt8* const pSourceHint = pReadAccess->GetScanline(y);
+            sal_uInt8* const pDestHint = pWriteAccess->GetScanline(y);
+            for (sal_Int32 x = 0; x <= nLastIndex; x++)
+            {
+                // This processes [nRadius * 2 + 1] pixels of source per resulting pixel
+                // TODO: try to optimize this to not process same pixels repeatedly
+                sal_Int32 iMin, iMax;
+                const bool bLookOutside = GetMinMax(x, rShared.mnRadius, nLastIndex, iMin, iMax);
+                Value<MorphologyOp, nComponentWidth> aResult(rShared, bLookOutside);
+                for (sal_Int32 i = iMin; i <= iMax; ++i)
+                    aResult.apply(pReadAccess, i, y, pSourceHint);
+
+                aResult.copy(pWriteAccess, x, y, pDestHint);
+            }
+        }
+    }
+
+    static void Vertical(FilterSharedData const& rShared, const sal_Int32 nStart,
+                         const sal_Int32 nEnd)
+    {
+        BitmapScopedReadAccess& pReadAccess = rShared.mpReadAccess;
+        BitmapScopedWriteAccess& pWriteAccess = rShared.mpWriteAccess;
+
+        const sal_Int32 nLastIndex = pReadAccess->Height() - 1;
+
+        for (sal_Int32 x = nStart; x <= nEnd; x++)
+        {
+            for (sal_Int32 y = 0; y <= nLastIndex; y++)
+            {
+                // This processes [nRadius * 2 + 1] pixels of source per resulting pixel
+                // TODO: try to optimize this to not process same pixels repeatedly
+                sal_Int32 iMin, iMax;
+                const bool bLookOutside = GetMinMax(y, rShared.mnRadius, nLastIndex, iMin, iMax);
+                Value<MorphologyOp, nComponentWidth> aResult(rShared, bLookOutside);
+                for (sal_Int32 i = iMin; i <= iMax; ++i)
+                    aResult.apply(pReadAccess, x, i);
+
+                aResult.copy(pWriteAccess, x, y);
+            }
+        }
+    }
+};
+
+typedef void (*passFn)(FilterSharedData const& rShared, sal_Int32 nStart, sal_Int32 nEnd);
+
+class FilterTask : public comphelper::ThreadTask
+{
+    passFn mpFunction;
+    FilterSharedData& mrShared;
+    sal_Int32 mnStart;
+    sal_Int32 mnEnd;
+
+public:
+    explicit FilterTask(const std::shared_ptr<comphelper::ThreadTaskTag>& pTag, passFn pFunction,
+                        FilterSharedData& rShared, sal_Int32 nStart, sal_Int32 nEnd)
+        : comphelper::ThreadTask(pTag)
+        , mpFunction(pFunction)
+        , mrShared(rShared)
+        , mnStart(nStart)
+        , mnEnd(nEnd)
+    {
+    }
+
+    virtual void doWork() override { mpFunction(mrShared, mnStart, mnEnd); }
+};
+
+constexpr sal_Int32 nThreadStrip = 16;
+
+template <typename MorphologyOp, int nComponentWidth>
+void runFilter(Bitmap& rBitmap, const sal_Int32 nRadius, const bool bParallel,
+               bool bUseValueOutside, sal_uInt8 nValueOutside)
+{
+    using myPass = pass<MorphologyOp, nComponentWidth>;
+    const sal_uInt8 nOutsideVal = bUseValueOutside ? nValueOutside : MorphologyOp::initVal;
+    if (bParallel)
+    {
+        try
+        {
+            comphelper::ThreadPool& rShared = comphelper::ThreadPool::getSharedOptimalPool();
+            auto pTag = comphelper::ThreadPool::createThreadTaskTag();
+
+            {
+                BitmapScopedReadAccess pReadAccess(rBitmap);
+                BitmapScopedWriteAccess pWriteAccess(rBitmap);
+                FilterSharedData aSharedData(pReadAccess, pWriteAccess, nRadius, nOutsideVal);
+
+                const sal_Int32 nLastIndex = pReadAccess->Height() - 1;
+                sal_Int32 nStripStart = 0;
+                for (; nStripStart < nLastIndex - nThreadStrip; nStripStart += nThreadStrip)
+                {
+                    sal_Int32 nStripEnd = nStripStart + nThreadStrip - 1;
+                    auto pTask(std::make_unique<FilterTask>(pTag, myPass::Horizontal, aSharedData,
+                                                            nStripStart, nStripEnd));
+                    rShared.pushTask(std::move(pTask));
+                }
+                // Do the last (or the only) strip in main thread without threading overhead
+                myPass::Horizontal(aSharedData, nStripStart, nLastIndex);
+                rShared.waitUntilDone(pTag);
+            }
+            {
+                BitmapScopedReadAccess pReadAccess(rBitmap);
+                BitmapScopedWriteAccess pWriteAccess(rBitmap);
+                FilterSharedData aSharedData(pReadAccess, pWriteAccess, nRadius, nOutsideVal);
+
+                const sal_Int32 nLastIndex = pReadAccess->Width() - 1;
+                sal_Int32 nStripStart = 0;
+                for (; nStripStart < nLastIndex - nThreadStrip; nStripStart += nThreadStrip)
+                {
+                    sal_Int32 nStripEnd = nStripStart + nThreadStrip - 1;
+                    auto pTask(std::make_unique<FilterTask>(pTag, myPass::Vertical, aSharedData,
+                                                            nStripStart, nStripEnd));
+                    rShared.pushTask(std::move(pTask));
+                }
+                // Do the last (or the only) strip in main thread without threading overhead
+                myPass::Vertical(aSharedData, nStripStart, nLastIndex);
+                rShared.waitUntilDone(pTag);
+            }
+        }
+        catch (...)
+        {
+            SAL_WARN("vcl.gdi", "threaded bitmap blurring failed");
+        }
+    }
+    else
+    {
+        {
+            BitmapScopedReadAccess pReadAccess(rBitmap);
+            BitmapScopedWriteAccess pWriteAccess(rBitmap);
+            FilterSharedData aSharedData(pReadAccess, pWriteAccess, nRadius, nOutsideVal);
+            sal_Int32 nFirstIndex = 0;
+            sal_Int32 nLastIndex = pReadAccess->Height() - 1;
+            myPass::Horizontal(aSharedData, nFirstIndex, nLastIndex);
+        }
+        {
+            BitmapScopedReadAccess pReadAccess(rBitmap);
+            BitmapScopedWriteAccess pWriteAccess(rBitmap);
+            FilterSharedData aSharedData(pReadAccess, pWriteAccess, nRadius, nOutsideVal);
+            sal_Int32 nFirstIndex = 0;
+            sal_Int32 nLastIndex = pReadAccess->Width() - 1;
+            myPass::Vertical(aSharedData, nFirstIndex, nLastIndex);
+        }
+    }
+}
+
+template <int nComponentWidth>
+void runFilter(Bitmap& rBitmap, BasicMorphologyOp op, sal_Int32 nRadius, bool bUseValueOutside,
+               sal_uInt8 nValueOutside)
+{
+    const bool bParallel = true;
+
+    if (op == BasicMorphologyOp::erode)
+        runFilter<ErodeOp, nComponentWidth>(rBitmap, nRadius, bParallel, bUseValueOutside,
+                                            nValueOutside);
+    else if (op == BasicMorphologyOp::dilate)
+        runFilter<DilateOp, nComponentWidth>(rBitmap, nRadius, bParallel, bUseValueOutside,
+                                             nValueOutside);
+}
+
+} // end anonymous namespace
+
+BitmapBasicMorphologyFilter::BitmapBasicMorphologyFilter(BasicMorphologyOp op, sal_Int32 nRadius)
+    : m_eOp(op)
+    , m_nRadius(nRadius)
+{
+}
+
+BitmapBasicMorphologyFilter::BitmapBasicMorphologyFilter(BasicMorphologyOp op, sal_Int32 nRadius,
+                                                         sal_uInt8 nValueOutside)
+    : m_eOp(op)
+    , m_nRadius(nRadius)
+    , m_nValueOutside(nValueOutside)
+    , m_bUseValueOutside(true)
+{
+}
+
+BitmapBasicMorphologyFilter::~BitmapBasicMorphologyFilter() = default;
+
+BitmapEx BitmapBasicMorphologyFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap result = filter(rBitmapEx.GetBitmap());
+    return BitmapEx(result, rBitmapEx.GetAlphaMask());
+}
+
+Bitmap BitmapBasicMorphologyFilter::filter(Bitmap const& rBitmap) const
+{
+    Bitmap bitmapCopy(rBitmap);
+    ScanlineFormat nScanlineFormat;
+    {
+        BitmapScopedReadAccess pReadAccess(bitmapCopy);
+        nScanlineFormat = pReadAccess ? pReadAccess->GetScanlineFormat() : ScanlineFormat::NONE;
+    }
+
+    switch (nScanlineFormat)
+    {
+        case ScanlineFormat::N24BitTcRgb:
+        case ScanlineFormat::N24BitTcBgr:
+            runFilter<24>(bitmapCopy, m_eOp, m_nRadius, m_bUseValueOutside, m_nValueOutside);
+            break;
+        case ScanlineFormat::N32BitTcMask:
+        case ScanlineFormat::N32BitTcBgra:
+            runFilter<32>(bitmapCopy, m_eOp, m_nRadius, m_bUseValueOutside, m_nValueOutside);
+            break;
+        case ScanlineFormat::N8BitPal:
+            runFilter<8>(bitmapCopy, m_eOp, m_nRadius, m_bUseValueOutside, m_nValueOutside);
+            break;
+        // TODO: handle 1-bit images
+        default:
+            // Use access' GetColor/SetPixel fallback
+            runFilter<0>(bitmapCopy, m_eOp, m_nRadius, m_bUseValueOutside, m_nValueOutside);
+            break;
+    }
+
+    return bitmapCopy;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapColorQuantizationFilter.cxx b/vcl/source/bitmap/BitmapColorQuantizationFilter.cxx
new file mode 100644
index 0000000000..9014bfe5dd
--- /dev/null
+++ b/vcl/source/bitmap/BitmapColorQuantizationFilter.cxx
@@ -0,0 +1,200 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <sal/config.h>
+
+#include <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapColorQuantizationFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+#include <algorithm>
+#include <cstdlib>
+
+BitmapEx BitmapColorQuantizationFilter::execute(BitmapEx const& aBitmapEx) const
+{
+    Bitmap aBitmap = aBitmapEx.GetBitmap();
+
+    if (vcl::numberOfColors(aBitmap.getPixelFormat()) <= sal_Int64(mnNewColorCount))
+        return BitmapEx(aBitmap);
+
+    BitmapScopedReadAccess pRAcc(aBitmap);
+    if (!pRAcc)
+        return BitmapEx();
+
+    auto const cappedNewColorCount = std::min(mnNewColorCount, sal_uInt16(256));
+
+    const sal_uInt32 nValidBits = 4;
+    const sal_uInt32 nRightShiftBits = 8 - nValidBits;
+    const sal_uInt32 nLeftShiftBits1 = nValidBits;
+    const sal_uInt32 nLeftShiftBits2 = nValidBits << 1;
+    const sal_uInt32 nColorsPerComponent = 1 << nValidBits;
+    const sal_uInt32 nColorOffset = 256 / nColorsPerComponent;
+    const sal_uInt32 nTotalColors = nColorsPerComponent * nColorsPerComponent * nColorsPerComponent;
+    const sal_Int32 nWidth = pRAcc->Width();
+    const sal_Int32 nHeight = pRAcc->Height();
+    std::unique_ptr<PopularColorCount[]> pCountTable(new PopularColorCount[nTotalColors]);
+
+    memset(pCountTable.get(), 0, nTotalColors * sizeof(PopularColorCount));
+
+    for (sal_Int32 nR = 0, nIndex = 0; nR < 256; nR += nColorOffset)
+    {
+        for (sal_Int32 nG = 0; nG < 256; nG += nColorOffset)
+        {
+            for (sal_Int32 nB = 0; nB < 256; nB += nColorOffset)
+            {
+                pCountTable[nIndex].mnIndex = nIndex;
+                nIndex++;
+            }
+        }
+    }
+
+    if (pRAcc->HasPalette())
+    {
+        for (sal_Int32 nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanlineRead = pRAcc->GetScanline(nY);
+            for (sal_Int32 nX = 0; nX < nWidth; nX++)
+            {
+                const BitmapColor& rCol
+                    = pRAcc->GetPaletteColor(pRAcc->GetIndexFromData(pScanlineRead, nX));
+                pCountTable[((static_cast<sal_uInt32>(rCol.GetRed()) >> nRightShiftBits)
+                             << nLeftShiftBits2)
+                            | ((static_cast<sal_uInt32>(rCol.GetGreen()) >> nRightShiftBits)
+                               << nLeftShiftBits1)
+                            | (static_cast<sal_uInt32>(rCol.GetBlue()) >> nRightShiftBits)]
+                    .mnCount++;
+            }
+        }
+    }
+    else
+    {
+        for (sal_Int32 nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanlineRead = pRAcc->GetScanline(nY);
+            for (sal_Int32 nX = 0; nX < nWidth; nX++)
+            {
+                const BitmapColor aCol(pRAcc->GetPixelFromData(pScanlineRead, nX));
+                pCountTable[((static_cast<sal_uInt32>(aCol.GetRed()) >> nRightShiftBits)
+                             << nLeftShiftBits2)
+                            | ((static_cast<sal_uInt32>(aCol.GetGreen()) >> nRightShiftBits)
+                               << nLeftShiftBits1)
+                            | (static_cast<sal_uInt32>(aCol.GetBlue()) >> nRightShiftBits)]
+                    .mnCount++;
+            }
+        }
+    }
+
+    BitmapPalette aNewPal(cappedNewColorCount);
+
+    std::qsort(pCountTable.get(), nTotalColors, sizeof(PopularColorCount),
+               [](const void* p1, const void* p2) {
+                   int nRet;
+
+                   if (static_cast<PopularColorCount const*>(p1)->mnCount
+                       < static_cast<PopularColorCount const*>(p2)->mnCount)
+                       nRet = 1;
+                   else if (static_cast<PopularColorCount const*>(p1)->mnCount
+                            == static_cast<PopularColorCount const*>(p2)->mnCount)
+                       nRet = 0;
+                   else
+                       nRet = -1;
+
+                   return nRet;
+               });
+
+    for (sal_uInt16 n = 0; n < cappedNewColorCount; n++)
+    {
+        const PopularColorCount& rPop = pCountTable[n];
+        aNewPal[n] = BitmapColor(
+            static_cast<sal_uInt8>((rPop.mnIndex >> nLeftShiftBits2) << nRightShiftBits),
+            static_cast<sal_uInt8>(((rPop.mnIndex >> nLeftShiftBits1) & (nColorsPerComponent - 1))
+                                   << nRightShiftBits),
+            static_cast<sal_uInt8>((rPop.mnIndex & (nColorsPerComponent - 1)) << nRightShiftBits));
+    }
+
+    Bitmap aNewBmp(aBitmap.GetSizePixel(), vcl::PixelFormat::N8_BPP, &aNewPal);
+    BitmapScopedWriteAccess pWAcc(aNewBmp);
+    if (!pWAcc)
+        return BitmapEx();
+
+    BitmapColor aDstCol(sal_uInt8(0));
+    std::unique_ptr<sal_uInt8[]> pIndexMap(new sal_uInt8[nTotalColors]);
+
+    for (sal_Int32 nR = 0, nIndex = 0; nR < 256; nR += nColorOffset)
+    {
+        for (sal_Int32 nG = 0; nG < 256; nG += nColorOffset)
+        {
+            for (sal_Int32 nB = 0; nB < 256; nB += nColorOffset)
+            {
+                pIndexMap[nIndex++] = static_cast<sal_uInt8>(aNewPal.GetBestIndex(
+                    BitmapColor(static_cast<sal_uInt8>(nR), static_cast<sal_uInt8>(nG),
+                                static_cast<sal_uInt8>(nB))));
+            }
+        }
+    }
+
+    if (pRAcc->HasPalette())
+    {
+        for (sal_Int32 nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWAcc->GetScanline(nY);
+            Scanline pScanlineRead = pRAcc->GetScanline(nY);
+            for (sal_Int32 nX = 0; nX < nWidth; nX++)
+            {
+                const BitmapColor& rCol
+                    = pRAcc->GetPaletteColor(pRAcc->GetIndexFromData(pScanlineRead, nX));
+                aDstCol.SetIndex(
+                    pIndexMap[((static_cast<sal_uInt32>(rCol.GetRed()) >> nRightShiftBits)
+                               << nLeftShiftBits2)
+                              | ((static_cast<sal_uInt32>(rCol.GetGreen()) >> nRightShiftBits)
+                                 << nLeftShiftBits1)
+                              | (static_cast<sal_uInt32>(rCol.GetBlue()) >> nRightShiftBits)]);
+                pWAcc->SetPixelOnData(pScanline, nX, aDstCol);
+            }
+        }
+    }
+    else
+    {
+        for (sal_Int32 nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWAcc->GetScanline(nY);
+            Scanline pScanlineRead = pRAcc->GetScanline(nY);
+
+            for (sal_Int32 nX = 0; nX < nWidth; nX++)
+            {
+                const BitmapColor aCol(pRAcc->GetPixelFromData(pScanlineRead, nX));
+                aDstCol.SetIndex(
+                    pIndexMap[((static_cast<sal_uInt32>(aCol.GetRed()) >> nRightShiftBits)
+                               << nLeftShiftBits2)
+                              | ((static_cast<sal_uInt32>(aCol.GetGreen()) >> nRightShiftBits)
+                                 << nLeftShiftBits1)
+                              | (static_cast<sal_uInt32>(aCol.GetBlue()) >> nRightShiftBits)]);
+                pWAcc->SetPixelOnData(pScanline, nX, aDstCol);
+            }
+        }
+    }
+
+    pWAcc.reset();
+    pCountTable.reset();
+    pRAcc.reset();
+
+    const MapMode aMap(aBitmap.GetPrefMapMode());
+    const Size aSize(aBitmap.GetPrefSize());
+
+    aBitmap = aNewBmp;
+
+    aBitmap.SetPrefMapMode(aMap);
+    aBitmap.SetPrefSize(aSize);
+
+    return BitmapEx(aBitmap);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapColorizeFilter.cxx b/vcl/source/bitmap/BitmapColorizeFilter.cxx
new file mode 100644
index 0000000000..21e996193e
--- /dev/null
+++ b/vcl/source/bitmap/BitmapColorizeFilter.cxx
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <tools/color.hxx>
+#include <tools/helpers.hxx>
+
+#include <vcl/BitmapWriteAccess.hxx>
+#include <bitmap/BitmapColorizeFilter.hxx>
+
+BitmapEx BitmapColorizeFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap = rBitmapEx.GetBitmap();
+    BitmapScopedWriteAccess pWriteAccess(aBitmap);
+
+    if (!pWriteAccess)
+        return rBitmapEx;
+
+    BitmapColor aBitmapColor;
+    const sal_Int32 nW = pWriteAccess->Width();
+    const sal_Int32 nH = pWriteAccess->Height();
+    std::vector<sal_uInt8> aMapR(256);
+    std::vector<sal_uInt8> aMapG(256);
+    std::vector<sal_uInt8> aMapB(256);
+    sal_Int32 nX;
+    sal_Int32 nY;
+
+    const sal_uInt8 cR = maColor.GetRed();
+    const sal_uInt8 cG = maColor.GetGreen();
+    const sal_uInt8 cB = maColor.GetBlue();
+
+    for (nX = 0; nX < 256; ++nX)
+    {
+        aMapR[nX] = std::clamp((nX + cR) / 2, sal_Int32(0), sal_Int32(255));
+        aMapG[nX] = std::clamp((nX + cG) / 2, sal_Int32(0), sal_Int32(255));
+        aMapB[nX] = std::clamp((nX + cB) / 2, sal_Int32(0), sal_Int32(255));
+    }
+
+    if (pWriteAccess->HasPalette())
+    {
+        for (sal_uInt16 i = 0, nCount = pWriteAccess->GetPaletteEntryCount(); i < nCount; i++)
+        {
+            const BitmapColor& rCol = pWriteAccess->GetPaletteColor(i);
+            aBitmapColor.SetRed(aMapR[rCol.GetRed()]);
+            aBitmapColor.SetGreen(aMapG[rCol.GetGreen()]);
+            aBitmapColor.SetBlue(aMapB[rCol.GetBlue()]);
+            pWriteAccess->SetPaletteColor(i, aBitmapColor);
+        }
+    }
+    else if (pWriteAccess->GetScanlineFormat() == ScanlineFormat::N24BitTcBgr)
+    {
+        for (nY = 0; nY < nH; ++nY)
+        {
+            Scanline pScan = pWriteAccess->GetScanline(nY);
+
+            for (nX = 0; nX < nW; ++nX)
+            {
+                *pScan = aMapB[*pScan];
+                pScan++;
+                *pScan = aMapG[*pScan];
+                pScan++;
+                *pScan = aMapR[*pScan];
+                pScan++;
+            }
+        }
+    }
+    else
+    {
+        for (nY = 0; nY < nH; ++nY)
+        {
+            Scanline pScanline = pWriteAccess->GetScanline(nY);
+            for (nX = 0; nX < nW; ++nX)
+            {
+                aBitmapColor = pWriteAccess->GetPixelFromData(pScanline, nX);
+                aBitmapColor.SetRed(aMapR[aBitmapColor.GetRed()]);
+                aBitmapColor.SetGreen(aMapG[aBitmapColor.GetGreen()]);
+                aBitmapColor.SetBlue(aMapB[aBitmapColor.GetBlue()]);
+                pWriteAccess->SetPixelOnData(pScanline, nX, aBitmapColor);
+            }
+        }
+    }
+
+    return rBitmapEx;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapConvolutionMatrixFilter.cxx b/vcl/source/bitmap/BitmapConvolutionMatrixFilter.cxx
new file mode 100644
index 0000000000..4a0d3d89a8
--- /dev/null
+++ b/vcl/source/bitmap/BitmapConvolutionMatrixFilter.cxx
@@ -0,0 +1,199 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <tools/helpers.hxx>
+
+#include <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapConvolutionMatrixFilter.hxx>
+#include <vcl/BitmapSharpenFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+#include <array>
+
+BitmapEx BitmapConvolutionMatrixFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+    const sal_Int32 nDivisor = 8;
+    BitmapScopedReadAccess pReadAcc(aBitmap);
+    if (!pReadAcc)
+        return BitmapEx();
+
+    Bitmap aNewBmp(aBitmap.GetSizePixel(), vcl::PixelFormat::N24_BPP);
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if (!pWriteAcc)
+        return BitmapEx();
+
+    const sal_Int32 nWidth = pWriteAcc->Width(), nWidth2 = nWidth + 2;
+    const sal_Int32 nHeight = pWriteAcc->Height(), nHeight2 = nHeight + 2;
+    std::unique_ptr<sal_Int32[]> pColm(new sal_Int32[nWidth2]);
+    std::unique_ptr<sal_Int32[]> pRows(new sal_Int32[nHeight2]);
+    std::unique_ptr<BitmapColor[]> pColRow1(new BitmapColor[nWidth2]);
+    std::unique_ptr<BitmapColor[]> pColRow2(new BitmapColor[nWidth2]);
+    std::unique_ptr<BitmapColor[]> pColRow3(new BitmapColor[nWidth2]);
+    BitmapColor* pRowTmp1 = pColRow1.get();
+    BitmapColor* pRowTmp2 = pColRow2.get();
+    BitmapColor* pRowTmp3 = pColRow3.get();
+    BitmapColor* pColor;
+    sal_Int32 nY, nX, i, nSumR, nSumG, nSumB, nMatrixVal, nTmp;
+    std::array<std::array<sal_Int32, 256>, 9> aKoeff;
+    sal_Int32* pTmp;
+
+    // create LUT of products of matrix value and possible color component values
+    for (nY = 0; nY < 9; nY++)
+    {
+        for (nX = nTmp = 0, nMatrixVal = mrMatrix[nY]; nX < 256; nX++, nTmp += nMatrixVal)
+        {
+            aKoeff[nY][nX] = nTmp;
+        }
+    }
+
+    // create column LUT
+    for (i = 0; i < nWidth2; i++)
+    {
+        pColm[i] = (i > 0) ? (i - 1) : 0;
+    }
+
+    pColm[nWidth + 1] = pColm[nWidth];
+
+    // create row LUT
+    for (i = 0; i < nHeight2; i++)
+    {
+        pRows[i] = (i > 0) ? (i - 1) : 0;
+    }
+
+    pRows[nHeight + 1] = pRows[nHeight];
+
+    // read first three rows of bitmap color
+    for (i = 0; i < nWidth2; i++)
+    {
+        pColRow1[i] = pReadAcc->GetColor(pRows[0], pColm[i]);
+        pColRow2[i] = pReadAcc->GetColor(pRows[1], pColm[i]);
+        pColRow3[i] = pReadAcc->GetColor(pRows[2], pColm[i]);
+    }
+
+    // do convolution
+    for (nY = 0; nY < nHeight;)
+    {
+        Scanline pScanline = pWriteAcc->GetScanline(nY);
+        for (nX = 0; nX < nWidth; nX++)
+        {
+            // first row
+            pTmp = aKoeff[0].data();
+            pColor = pRowTmp1 + nX;
+            nSumR = pTmp[pColor->GetRed()];
+            nSumG = pTmp[pColor->GetGreen()];
+            nSumB = pTmp[pColor->GetBlue()];
+
+            pTmp = aKoeff[1].data();
+            nSumR += pTmp[(++pColor)->GetRed()];
+            nSumG += pTmp[pColor->GetGreen()];
+            nSumB += pTmp[pColor->GetBlue()];
+
+            pTmp = aKoeff[2].data();
+            nSumR += pTmp[(++pColor)->GetRed()];
+            nSumG += pTmp[pColor->GetGreen()];
+            nSumB += pTmp[pColor->GetBlue()];
+
+            // second row
+            pTmp = aKoeff[3].data();
+            pColor = pRowTmp2 + nX;
+            nSumR += pTmp[pColor->GetRed()];
+            nSumG += pTmp[pColor->GetGreen()];
+            nSumB += pTmp[pColor->GetBlue()];
+
+            pTmp = aKoeff[4].data();
+            nSumR += pTmp[(++pColor)->GetRed()];
+            nSumG += pTmp[pColor->GetGreen()];
+            nSumB += pTmp[pColor->GetBlue()];
+
+            pTmp = aKoeff[5].data();
+            nSumR += pTmp[(++pColor)->GetRed()];
+            nSumG += pTmp[pColor->GetGreen()];
+            nSumB += pTmp[pColor->GetBlue()];
+
+            // third row
+            pTmp = aKoeff[6].data();
+            pColor = pRowTmp3 + nX;
+            nSumR += pTmp[pColor->GetRed()];
+            nSumG += pTmp[pColor->GetGreen()];
+            nSumB += pTmp[pColor->GetBlue()];
+
+            pTmp = aKoeff[7].data();
+            nSumR += pTmp[(++pColor)->GetRed()];
+            nSumG += pTmp[pColor->GetGreen()];
+            nSumB += pTmp[pColor->GetBlue()];
+
+            pTmp = aKoeff[8].data();
+            nSumR += pTmp[(++pColor)->GetRed()];
+            nSumG += pTmp[pColor->GetGreen()];
+            nSumB += pTmp[pColor->GetBlue()];
+
+            // calculate destination color
+            pWriteAcc->SetPixelOnData(
+                pScanline, nX,
+                BitmapColor(static_cast<sal_uInt8>(
+                                std::clamp(nSumR / nDivisor, sal_Int32(0), sal_Int32(255))),
+                            static_cast<sal_uInt8>(
+                                std::clamp(nSumG / nDivisor, sal_Int32(0), sal_Int32(255))),
+                            static_cast<sal_uInt8>(
+                                std::clamp(nSumB / nDivisor, sal_Int32(0), sal_Int32(255)))));
+        }
+
+        if (++nY < nHeight)
+        {
+            if (pRowTmp1 == pColRow1.get())
+            {
+                pRowTmp1 = pColRow2.get();
+                pRowTmp2 = pColRow3.get();
+                pRowTmp3 = pColRow1.get();
+            }
+            else if (pRowTmp1 == pColRow2.get())
+            {
+                pRowTmp1 = pColRow3.get();
+                pRowTmp2 = pColRow1.get();
+                pRowTmp3 = pColRow2.get();
+            }
+            else
+            {
+                pRowTmp1 = pColRow1.get();
+                pRowTmp2 = pColRow2.get();
+                pRowTmp3 = pColRow3.get();
+            }
+
+            for (i = 0; i < nWidth2; i++)
+            {
+                pRowTmp3[i] = pReadAcc->GetColor(pRows[nY + 2], pColm[i]);
+            }
+        }
+    }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+
+    const MapMode aMap(aBitmap.GetPrefMapMode());
+    const Size aPrefSize(aBitmap.GetPrefSize());
+
+    aBitmap = aNewBmp;
+
+    aBitmap.SetPrefMapMode(aMap);
+    aBitmap.SetPrefSize(aPrefSize);
+
+    return BitmapEx(aBitmap);
+}
+
+const sal_Int32 g_SharpenMatrix[] = { -1, -1, -1, -1, 16, -1, -1, -1, -1 };
+
+BitmapSharpenFilter::BitmapSharpenFilter()
+    : BitmapConvolutionMatrixFilter(g_SharpenMatrix)
+{
+}
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapDisabledImageFilter.cxx b/vcl/source/bitmap/BitmapDisabledImageFilter.cxx
new file mode 100644
index 0000000000..e38c450d79
--- /dev/null
+++ b/vcl/source/bitmap/BitmapDisabledImageFilter.cxx
@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <vcl/BitmapWriteAccess.hxx>
+#include <bitmap/BitmapDisabledImageFilter.hxx>
+
+BitmapEx BitmapDisabledImageFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    const Size aSize(rBitmapEx.GetSizePixel());
+
+    // keep disable image at same depth as original where possible, otherwise
+    // use 8 bit
+    auto ePixelFormat = rBitmapEx.getPixelFormat();
+    if (sal_uInt16(ePixelFormat) < 8)
+        ePixelFormat = vcl::PixelFormat::N8_BPP;
+
+    const BitmapPalette* pPal
+        = vcl::isPalettePixelFormat(ePixelFormat) ? &Bitmap::GetGreyPalette(256) : nullptr;
+    Bitmap aGrey(aSize, ePixelFormat, pPal);
+    BitmapScopedWriteAccess pGrey(aGrey);
+
+    BitmapEx aReturnBitmap;
+    Bitmap aReadBitmap(rBitmapEx.GetBitmap());
+    BitmapScopedReadAccess pRead(aReadBitmap);
+    if (pRead && pGrey)
+    {
+        for (sal_Int32 nY = 0; nY < sal_Int32(aSize.Height()); ++nY)
+        {
+            Scanline pGreyScan = pGrey->GetScanline(nY);
+            Scanline pReadScan = pRead->GetScanline(nY);
+
+            for (sal_Int32 nX = 0; nX < sal_Int32(aSize.Width()); ++nX)
+            {
+                // Get the luminance from RGB color and remap the value from 0-255 to 160-224
+                const BitmapColor aColor = pRead->GetPixelFromData(pReadScan, nX);
+                sal_uInt8 nLum(aColor.GetLuminance() / 4 + 160);
+                BitmapColor aGreyValue(ColorAlpha, nLum, nLum, nLum, aColor.GetAlpha());
+                pGrey->SetPixelOnData(pGreyScan, nX, aGreyValue);
+            }
+        }
+    }
+
+    if (rBitmapEx.IsAlpha())
+    {
+        aReturnBitmap = BitmapEx(aGrey, rBitmapEx.GetAlphaMask());
+    }
+    else
+        aReturnBitmap = BitmapEx(aGrey);
+
+    return aReturnBitmap;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapDuoToneFilter.cxx b/vcl/source/bitmap/BitmapDuoToneFilter.cxx
new file mode 100644
index 0000000000..c9cc10b1d1
--- /dev/null
+++ b/vcl/source/bitmap/BitmapDuoToneFilter.cxx
@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapDuoToneFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+static sal_uInt8 lcl_getDuotoneColorComponent(sal_uInt8 base, sal_uInt16 color1, sal_uInt16 color2)
+{
+    color2 = color2 * base / 0xFF;
+    color1 = color1 * (0xFF - base) / 0xFF;
+
+    return static_cast<sal_uInt8>(color1 + color2);
+}
+
+BitmapEx BitmapDuoToneFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+    const sal_Int32 nWidth = aBitmap.GetSizePixel().Width();
+    const sal_Int32 nHeight = aBitmap.GetSizePixel().Height();
+
+    Bitmap aResultBitmap(aBitmap.GetSizePixel(), vcl::PixelFormat::N24_BPP);
+    BitmapScopedReadAccess pReadAcc(aBitmap);
+    BitmapScopedWriteAccess pWriteAcc(aResultBitmap);
+    const BitmapColor aColorOne(mnColorOne);
+    const BitmapColor aColorTwo(mnColorTwo);
+
+    for (sal_Int32 x = 0; x < nWidth; x++)
+    {
+        for (sal_Int32 y = 0; y < nHeight; y++)
+        {
+            BitmapColor aColor = pReadAcc->GetColor(y, x);
+            sal_uInt8 nLuminance = aColor.GetLuminance();
+            BitmapColor aResultColor(
+                lcl_getDuotoneColorComponent(nLuminance, aColorOne.GetRed(), aColorTwo.GetRed()),
+                lcl_getDuotoneColorComponent(nLuminance, aColorOne.GetGreen(),
+                                             aColorTwo.GetGreen()),
+                lcl_getDuotoneColorComponent(nLuminance, aColorOne.GetBlue(), aColorTwo.GetBlue()));
+            pWriteAcc->SetPixel(y, x, aResultColor);
+        }
+    }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+    aBitmap.ReassignWithSize(aResultBitmap);
+
+    return BitmapEx(aBitmap);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapEmbossGreyFilter.cxx b/vcl/source/bitmap/BitmapEmbossGreyFilter.cxx
new file mode 100644
index 0000000000..6fa5dd5c12
--- /dev/null
+++ b/vcl/source/bitmap/BitmapEmbossGreyFilter.cxx
@@ -0,0 +1,136 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <sal/config.h>
+
+#include <tools/helpers.hxx>
+
+#include <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapEmbossGreyFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+#include <algorithm>
+
+BitmapEx BitmapEmbossGreyFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+    if (!aBitmap.ImplMakeGreyscales())
+        return BitmapEx();
+
+    BitmapScopedReadAccess pReadAcc(aBitmap);
+    if (!pReadAcc)
+        return BitmapEx();
+
+    Bitmap aNewBmp(aBitmap.GetSizePixel(), vcl::PixelFormat::N8_BPP, &pReadAcc->GetPalette());
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if (!pWriteAcc)
+        return BitmapEx();
+
+    BitmapColor aGrey(sal_uInt8(0));
+    const sal_Int32 nWidth = pWriteAcc->Width();
+    const sal_Int32 nHeight = pWriteAcc->Height();
+    const double fAzim = toRadians(mnAzimuthAngle);
+    const double fElev = toRadians(mnElevationAngle);
+    std::vector<sal_Int32> pHMap(nWidth + 2);
+    std::vector<sal_Int32> pVMap(nHeight + 2);
+    const double nLx = cos(fAzim) * cos(fElev) * 255.0;
+    const double nLy = sin(fAzim) * cos(fElev) * 255.0;
+    const double nLz = sin(fElev) * 255.0;
+    const double nNz = 6 * 255.0 / 4;
+    const double nNzLz = nNz * nLz;
+    const sal_uInt8 cLz = FRound(std::clamp(nLz, 0.0, 255.0));
+
+    // fill mapping tables
+    pHMap[0] = 0;
+
+    for (sal_Int32 nX = 1; nX <= nWidth; nX++)
+    {
+        pHMap[nX] = nX - 1;
+    }
+
+    pHMap[nWidth + 1] = nWidth - 1;
+
+    pVMap[0] = 0;
+
+    for (sal_Int32 nY = 1; nY <= nHeight; nY++)
+    {
+        pVMap[nY] = nY - 1;
+    }
+
+    pVMap[nHeight + 1] = nHeight - 1;
+
+    for (sal_Int32 nY = 0; nY < nHeight; nY++)
+    {
+        sal_Int32 nGrey11 = pReadAcc->GetPixel(pVMap[nY], pHMap[0]).GetIndex();
+        sal_Int32 nGrey12 = pReadAcc->GetPixel(pVMap[nY], pHMap[1]).GetIndex();
+        sal_Int32 nGrey13 = pReadAcc->GetPixel(pVMap[nY], pHMap[2]).GetIndex();
+        sal_Int32 nGrey21 = pReadAcc->GetPixel(pVMap[nY + 1], pHMap[0]).GetIndex();
+        sal_Int32 nGrey22 = pReadAcc->GetPixel(pVMap[nY + 1], pHMap[1]).GetIndex();
+        sal_Int32 nGrey23 = pReadAcc->GetPixel(pVMap[nY + 1], pHMap[2]).GetIndex();
+        sal_Int32 nGrey31 = pReadAcc->GetPixel(pVMap[nY + 2], pHMap[0]).GetIndex();
+        sal_Int32 nGrey32 = pReadAcc->GetPixel(pVMap[nY + 2], pHMap[1]).GetIndex();
+        sal_Int32 nGrey33 = pReadAcc->GetPixel(pVMap[nY + 2], pHMap[2]).GetIndex();
+
+        Scanline pScanline = pWriteAcc->GetScanline(nY);
+        for (sal_Int32 nX = 0; nX < nWidth; nX++)
+        {
+            const sal_Int32 nNx = nGrey11 + nGrey21 + nGrey31 - nGrey13 - nGrey23 - nGrey33;
+            const sal_Int32 nNy = nGrey31 + nGrey32 + nGrey33 - nGrey11 - nGrey12 - nGrey13;
+
+            if (!nNx && !nNy)
+            {
+                aGrey.SetIndex(cLz);
+            }
+            else if (double nDotL = nNx * nLx + nNy * nLy + nNzLz; nDotL < 0)
+            {
+                aGrey.SetIndex(0);
+            }
+            else
+            {
+                const double fGrey = nDotL / std::hypot(nNx, nNy, nNz);
+                aGrey.SetIndex(FRound(std::clamp(fGrey, 0.0, 255.0)));
+            }
+
+            pWriteAcc->SetPixelOnData(pScanline, nX, aGrey);
+
+            if (nX < (nWidth - 1))
+            {
+                const sal_Int32 nNextX = pHMap[nX + 3];
+
+                nGrey11 = nGrey12;
+                nGrey12 = nGrey13;
+                nGrey13 = pReadAcc->GetPixel(pVMap[nY], nNextX).GetIndex();
+                nGrey21 = nGrey22;
+                nGrey22 = nGrey23;
+                nGrey23 = pReadAcc->GetPixel(pVMap[nY + 1], nNextX).GetIndex();
+                nGrey31 = nGrey32;
+                nGrey32 = nGrey33;
+                nGrey33 = pReadAcc->GetPixel(pVMap[nY + 2], nNextX).GetIndex();
+            }
+        }
+    }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+
+    const MapMode aMap(aBitmap.GetPrefMapMode());
+    const Size aPrefSize(aBitmap.GetPrefSize());
+
+    aBitmap = aNewBmp;
+
+    aBitmap.SetPrefMapMode(aMap);
+    aBitmap.SetPrefSize(aPrefSize);
+
+    return BitmapEx(aBitmap);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapEx.cxx b/vcl/source/bitmap/BitmapEx.cxx
new file mode 100644
index 0000000000..40feacbf66
--- /dev/null
+++ b/vcl/source/bitmap/BitmapEx.cxx
@@ -0,0 +1,1523 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/log.hxx>
+#include <rtl/crc.h>
+#include <rtl/math.hxx>
+#include <o3tl/underlyingenumvalue.hxx>
+#include <osl/diagnose.h>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <basegfx/color/bcolormodifier.hxx>
+
+#include <vcl/ImageTree.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/alpha.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/BitmapMonochromeFilter.hxx>
+
+// BitmapEx::Create
+#include <salbmp.hxx>
+#include <salinst.hxx>
+#include <svdata.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+#include <bitmap/BitmapMaskToAlphaFilter.hxx>
+
+#include <o3tl/any.hxx>
+#include <tools/stream.hxx>
+#include <vcl/filter/PngImageWriter.hxx>
+
+#include <com/sun/star/beans/XFastPropertySet.hpp>
+
+#include <memory>
+
+using namespace ::com::sun::star;
+
+BitmapEx::BitmapEx()
+{
+}
+
+BitmapEx::BitmapEx( const BitmapEx& ) = default;
+
+BitmapEx::BitmapEx( const BitmapEx& rBitmapEx, Point aSrc, Size aSize )
+{
+    if( rBitmapEx.IsEmpty() || aSize.IsEmpty() )
+        return;
+
+    maBitmap = Bitmap(aSize, rBitmapEx.maBitmap.getPixelFormat());
+    SetSizePixel(aSize);
+    if( rBitmapEx.IsAlpha() )
+        maAlphaMask = AlphaMask( aSize );
+
+    tools::Rectangle aDestRect( Point( 0, 0 ), aSize );
+    tools::Rectangle aSrcRect( aSrc, aSize );
+    CopyPixel( aDestRect, aSrcRect, rBitmapEx );
+}
+
+BitmapEx::BitmapEx(Size aSize, vcl::PixelFormat ePixelFormat)
+{
+    maBitmap = Bitmap(aSize, ePixelFormat);
+    SetSizePixel(aSize);
+}
+
+BitmapEx::BitmapEx( const OUString& rIconName )
+{
+    loadFromIconTheme( rIconName );
+}
+
+void BitmapEx::loadFromIconTheme( const OUString& rIconName )
+{
+    bool bSuccess;
+    OUString aIconTheme;
+
+    try
+    {
+        aIconTheme = Application::GetSettings().GetStyleSettings().DetermineIconTheme();
+        bSuccess = ImageTree::get().loadImage(rIconName, aIconTheme, *this, true);
+    }
+    catch (...)
+    {
+        bSuccess = false;
+    }
+
+    SAL_WARN_IF( !bSuccess, "vcl", "BitmapEx::BitmapEx(): could not load image " << rIconName << " via icon theme " << aIconTheme);
+}
+
+BitmapEx::BitmapEx( const Bitmap& rBmp ) :
+        maBitmap     ( rBmp ),
+        maBitmapSize ( maBitmap.GetSizePixel() )
+{
+}
+
+BitmapEx::BitmapEx( const Bitmap& rBmp, const Bitmap& rMask ) :
+        maBitmap         ( rBmp ),
+        maBitmapSize     ( maBitmap.GetSizePixel() )
+{
+    if (rMask.IsEmpty())
+        return;
+
+    assert(typeid(rMask) != typeid(AlphaMask)
+        && "If this mask is actually an AlphaMask, then it will be inverted unnecessarily "
+           "and the alpha channel will be wrong");
+
+    if( rMask.getPixelFormat() == vcl::PixelFormat::N8_BPP && rMask.HasGreyPalette8Bit() )
+    {
+        maAlphaMask = rMask;
+        maAlphaMask.Invert();
+    }
+    else if( rMask.getPixelFormat() == vcl::PixelFormat::N8_BPP )
+    {
+        BitmapEx aMaskEx(rMask);
+        BitmapFilter::Filter(aMaskEx, BitmapMonochromeFilter(255));
+        aMaskEx.Invert();
+        maAlphaMask = aMaskEx.GetBitmap();
+    }
+    else
+    {
+        // convert to alpha bitmap
+        SAL_WARN( "vcl", "BitmapEx: forced mask to monochrome");
+        BitmapEx aMaskEx(rMask);
+        BitmapFilter::Filter(aMaskEx, BitmapMonochromeFilter(255));
+        aMaskEx.Invert();
+        maAlphaMask = aMaskEx.GetBitmap();
+    }
+
+    if (!maBitmap.IsEmpty() && maBitmap.GetSizePixel() != maAlphaMask.GetSizePixel())
+    {
+        OSL_ENSURE(false, "Mask size differs from Bitmap size, corrected Mask (!)");
+        maAlphaMask.Scale(maBitmap.GetSizePixel(), BmpScaleFlag::Fast);
+    }
+}
+
+BitmapEx::BitmapEx( const Bitmap& rBmp, const AlphaMask& rAlphaMask ) :
+        maBitmap         ( rBmp ),
+        maAlphaMask      ( rAlphaMask ),
+        maBitmapSize     ( maBitmap.GetSizePixel() )
+{
+    if (!maBitmap.IsEmpty() && !maAlphaMask.IsEmpty() && maBitmap.GetSizePixel() != maAlphaMask.GetSizePixel())
+    {
+        OSL_ENSURE(false, "Alpha size differs from Bitmap size, corrected Mask (!)");
+        maAlphaMask.Scale(rBmp.GetSizePixel(), BmpScaleFlag::Fast);
+    }
+}
+
+
+BitmapEx::BitmapEx( const Bitmap& rBmp, const Color& rTransparentColor ) :
+        maBitmap             ( rBmp ),
+        maBitmapSize         ( maBitmap.GetSizePixel() )
+{
+    maAlphaMask = maBitmap.CreateAlphaMask( rTransparentColor );
+
+    SAL_WARN_IF(rBmp.GetSizePixel() != maAlphaMask.GetSizePixel(), "vcl",
+                "BitmapEx::BitmapEx(): size mismatch for bitmap and alpha mask.");
+}
+
+
+BitmapEx& BitmapEx::operator=( const BitmapEx& ) = default;
+
+bool BitmapEx::operator==( const BitmapEx& rBitmapEx ) const
+{
+    if (GetSizePixel() != rBitmapEx.GetSizePixel())
+        return false;
+
+    if (maBitmap != rBitmapEx.maBitmap)
+        return false;
+
+    return maAlphaMask == rBitmapEx.maAlphaMask;
+}
+
+bool BitmapEx::IsEmpty() const
+{
+    return( maBitmap.IsEmpty() && maAlphaMask.IsEmpty() );
+}
+
+void BitmapEx::SetEmpty()
+{
+    maBitmap.SetEmpty();
+    maAlphaMask.SetEmpty();
+}
+
+void BitmapEx::Clear()
+{
+    SetEmpty();
+}
+
+void BitmapEx::ClearAlpha()
+{
+    maAlphaMask.SetEmpty();
+}
+
+bool BitmapEx::IsAlpha() const
+{
+    return !maAlphaMask.IsEmpty();
+}
+
+const Bitmap& BitmapEx::GetBitmap() const
+{
+    return maBitmap;
+}
+
+Bitmap BitmapEx::GetBitmap( Color aTransparentReplaceColor ) const
+{
+    Bitmap aRetBmp( maBitmap );
+
+    if( !maAlphaMask.IsEmpty() )
+    {
+        aRetBmp.Replace( maAlphaMask, aTransparentReplaceColor );
+    }
+
+    return aRetBmp;
+}
+
+sal_Int64 BitmapEx::GetSizeBytes() const
+{
+    sal_Int64 nSizeBytes = maBitmap.GetSizeBytes();
+
+    if( !maAlphaMask.IsEmpty() )
+        nSizeBytes += maAlphaMask.GetSizeBytes();
+
+    return nSizeBytes;
+}
+
+BitmapChecksum BitmapEx::GetChecksum() const
+{
+    BitmapChecksum  nCrc = maBitmap.GetChecksum();
+
+    if( !maAlphaMask.IsEmpty() )
+    {
+        BitmapChecksumOctetArray aBCOA;
+        BCToBCOA( maAlphaMask.GetChecksum(), aBCOA );
+        nCrc = rtl_crc32( nCrc, aBCOA, BITMAP_CHECKSUM_SIZE );
+    }
+
+    return nCrc;
+}
+
+void BitmapEx::SetSizePixel(const Size& rNewSize)
+{
+    maBitmapSize = rNewSize;
+}
+
+bool BitmapEx::Invert()
+{
+    bool bRet = false;
+
+    if (!maBitmap.IsEmpty())
+        bRet = maBitmap.Invert();
+
+    return bRet;
+}
+
+bool BitmapEx::Mirror( BmpMirrorFlags nMirrorFlags )
+{
+    bool bRet = false;
+
+    if( !maBitmap.IsEmpty() )
+    {
+        bRet = maBitmap.Mirror( nMirrorFlags );
+
+        if( bRet && !maAlphaMask.IsEmpty() )
+            maAlphaMask.Mirror( nMirrorFlags );
+    }
+
+    return bRet;
+}
+
+bool BitmapEx::Scale( const double& rScaleX, const double& rScaleY, BmpScaleFlag nScaleFlag )
+{
+    bool bRet = false;
+
+    if( !maBitmap.IsEmpty() )
+    {
+        bRet = maBitmap.Scale( rScaleX, rScaleY, nScaleFlag );
+
+        if( bRet && !maAlphaMask.IsEmpty() )
+        {
+            maAlphaMask.Scale( rScaleX, rScaleY, nScaleFlag );
+        }
+
+        SetSizePixel(maBitmap.GetSizePixel());
+
+        SAL_WARN_IF( !maAlphaMask.IsEmpty() && maBitmap.GetSizePixel() != maAlphaMask.GetSizePixel(), "vcl",
+                    "BitmapEx::Scale(): size mismatch for bitmap and alpha mask." );
+    }
+
+    return bRet;
+}
+
+bool BitmapEx::Scale( const Size& rNewSize, BmpScaleFlag nScaleFlag )
+{
+    bool bRet;
+
+    if (GetSizePixel().Width() && GetSizePixel().Height()
+            && (rNewSize.Width()  != GetSizePixel().Width()
+                    || rNewSize.Height() != GetSizePixel().Height() ) )
+    {
+        bRet = Scale( static_cast<double>(rNewSize.Width()) / GetSizePixel().Width(),
+                      static_cast<double>(rNewSize.Height()) / GetSizePixel().Height(),
+                      nScaleFlag );
+    }
+    else
+    {
+        bRet = true;
+    }
+
+    return bRet;
+}
+
+bool BitmapEx::Rotate( Degree10 nAngle10, const Color& rFillColor )
+{
+    bool bRet = false;
+
+    if( !maBitmap.IsEmpty() )
+    {
+        const bool bTransRotate = ( COL_TRANSPARENT == rFillColor );
+
+        if( bTransRotate )
+        {
+            bRet = maBitmap.Rotate( nAngle10, COL_BLACK );
+
+            if( maAlphaMask.IsEmpty() )
+            {
+                maAlphaMask = Bitmap(GetSizePixel(), vcl::PixelFormat::N8_BPP, &Bitmap::GetGreyPalette(256));
+                maAlphaMask.Erase( 0 );
+            }
+
+            if( bRet && !maAlphaMask.IsEmpty() )
+                maAlphaMask.Rotate( nAngle10, COL_ALPHA_TRANSPARENT );
+        }
+        else
+        {
+            bRet = maBitmap.Rotate( nAngle10, rFillColor );
+
+            if( bRet && !maAlphaMask.IsEmpty() )
+                maAlphaMask.Rotate( nAngle10, COL_ALPHA_TRANSPARENT );
+        }
+
+        SetSizePixel(maBitmap.GetSizePixel());
+
+        SAL_WARN_IF(!maAlphaMask.IsEmpty() && maBitmap.GetSizePixel() != maAlphaMask.GetSizePixel(), "vcl",
+                    "BitmapEx::Rotate(): size mismatch for bitmap and alpha mask.");
+    }
+
+    return bRet;
+}
+
+bool BitmapEx::Crop( const tools::Rectangle& rRectPixel )
+{
+    bool bRet = false;
+
+    if( !maBitmap.IsEmpty() )
+    {
+        bRet = maBitmap.Crop( rRectPixel );
+
+        if( bRet && !maAlphaMask.IsEmpty() )
+            maAlphaMask.Crop( rRectPixel );
+
+        SetSizePixel(maBitmap.GetSizePixel());
+
+        SAL_WARN_IF(!maAlphaMask.IsEmpty() && maBitmap.GetSizePixel() != maAlphaMask.GetSizePixel(), "vcl",
+                    "BitmapEx::Crop(): size mismatch for bitmap and alpha mask.");
+    }
+
+    return bRet;
+}
+
+bool BitmapEx::Convert( BmpConversion eConversion )
+{
+    return !maBitmap.IsEmpty() && maBitmap.Convert( eConversion );
+}
+
+void BitmapEx::Expand( sal_Int32 nDX, sal_Int32 nDY, bool bExpandTransparent )
+{
+    bool bRet = false;
+
+    if( maBitmap.IsEmpty() )
+        return;
+
+    bRet = maBitmap.Expand( nDX, nDY );
+
+    if( bRet && !maAlphaMask.IsEmpty() )
+    {
+        Color aColor( bExpandTransparent ? COL_ALPHA_TRANSPARENT : COL_ALPHA_OPAQUE );
+        maAlphaMask.Expand( nDX, nDY, &aColor );
+    }
+
+    SetSizePixel(maBitmap.GetSizePixel());
+
+    SAL_WARN_IF(!maAlphaMask.IsEmpty() && maBitmap.GetSizePixel() != maAlphaMask.GetSizePixel(), "vcl",
+                "BitmapEx::Expand(): size mismatch for bitmap and alpha mask.");
+}
+
+bool BitmapEx::CopyPixel( const tools::Rectangle& rRectDst, const tools::Rectangle& rRectSrc )
+{
+    if( maBitmap.IsEmpty() )
+        return false;
+
+    bool bRet = maBitmap.CopyPixel( rRectDst, rRectSrc );
+
+    if( bRet && !maAlphaMask.IsEmpty() )
+        maAlphaMask.CopyPixel( rRectDst, rRectSrc );
+
+    return bRet;
+}
+
+bool BitmapEx::CopyPixel( const tools::Rectangle& rRectDst, const tools::Rectangle& rRectSrc,
+                          const BitmapEx& rBmpExSrc )
+{
+    if( maBitmap.IsEmpty() )
+        return false;
+
+    if (!maBitmap.CopyPixel( rRectDst, rRectSrc, rBmpExSrc.maBitmap ))
+        return false;
+
+    if( rBmpExSrc.IsAlpha() )
+    {
+        if( IsAlpha() )
+            // cast to use the optimized AlphaMask::CopyPixel
+            maAlphaMask.CopyPixel_AlphaOptimized( rRectDst, rRectSrc, rBmpExSrc.maAlphaMask );
+        else
+        {
+            sal_uInt8 nTransparencyOpaque = 0;
+            maAlphaMask = AlphaMask(GetSizePixel(), &nTransparencyOpaque);
+            maAlphaMask.CopyPixel( rRectDst, rRectSrc, rBmpExSrc.maAlphaMask );
+        }
+    }
+    else if (IsAlpha())
+    {
+        sal_uInt8 nTransparencyOpaque = 0;
+        const AlphaMask aAlphaSrc(rBmpExSrc.GetSizePixel(), &nTransparencyOpaque);
+
+        maAlphaMask.CopyPixel( rRectDst, rRectSrc, aAlphaSrc );
+    }
+
+    return true;
+}
+
+bool BitmapEx::Erase( const Color& rFillColor )
+{
+    bool bRet = false;
+
+    if( !maBitmap.IsEmpty() )
+    {
+        bRet = maBitmap.Erase( rFillColor );
+
+        if( bRet && !maAlphaMask.IsEmpty() )
+        {
+            // Respect transparency on fill color
+            if( rFillColor.IsTransparent() )
+                maAlphaMask.Erase( 255 - rFillColor.GetAlpha() );
+            else
+                maAlphaMask.Erase( 0 );
+        }
+    }
+
+    return bRet;
+}
+
+void BitmapEx::Replace( const Color& rSearchColor, const Color& rReplaceColor )
+{
+    if (!maBitmap.IsEmpty())
+        maBitmap.Replace( rSearchColor, rReplaceColor );
+}
+
+void BitmapEx::Replace( const Color* pSearchColors, const Color* pReplaceColors, size_t nColorCount )
+{
+    if (!maBitmap.IsEmpty())
+        maBitmap.Replace( pSearchColors, pReplaceColors, nColorCount, /*pTols*/nullptr );
+}
+
+bool BitmapEx::Adjust( short nLuminancePercent, short nContrastPercent,
+                       short nChannelRPercent, short nChannelGPercent, short nChannelBPercent,
+                       double fGamma, bool bInvert, bool msoBrightness )
+{
+    return !maBitmap.IsEmpty() && maBitmap.Adjust( nLuminancePercent, nContrastPercent,
+                                        nChannelRPercent, nChannelGPercent, nChannelBPercent,
+                                        fGamma, bInvert, msoBrightness );
+}
+
+void BitmapEx::Draw( OutputDevice* pOutDev, const Point& rDestPt ) const
+{
+    pOutDev->DrawBitmapEx( rDestPt, *this );
+}
+
+void BitmapEx::Draw( OutputDevice* pOutDev,
+                     const Point& rDestPt, const Size& rDestSize ) const
+{
+    pOutDev->DrawBitmapEx( rDestPt, rDestSize, *this );
+}
+
+BitmapEx BitmapEx:: AutoScaleBitmap(BitmapEx const & aBitmap, const tools::Long aStandardSize)
+{
+    Point aEmptyPoint(0,0);
+    double imgposX = 0;
+    double imgposY = 0;
+    BitmapEx  aRet = aBitmap;
+    double imgOldWidth = aRet.GetSizePixel().Width();
+    double imgOldHeight = aRet.GetSizePixel().Height();
+
+    if (imgOldWidth >= aStandardSize || imgOldHeight >= aStandardSize)
+    {
+        sal_Int32 imgNewWidth = 0;
+        sal_Int32 imgNewHeight = 0;
+        if (imgOldWidth >= imgOldHeight)
+        {
+            imgNewWidth = aStandardSize;
+            imgNewHeight = sal_Int32(imgOldHeight / (imgOldWidth / aStandardSize) + 0.5);
+            imgposX = 0;
+            imgposY = (aStandardSize - (imgOldHeight / (imgOldWidth / aStandardSize) + 0.5)) / 2 + 0.5;
+        }
+        else
+        {
+            imgNewHeight = aStandardSize;
+            imgNewWidth = sal_Int32(imgOldWidth / (imgOldHeight / aStandardSize) + 0.5);
+            imgposY = 0;
+            imgposX = (aStandardSize - (imgOldWidth / (imgOldHeight / aStandardSize) + 0.5)) / 2 + 0.5;
+        }
+
+        Size aScaledSize( imgNewWidth, imgNewHeight );
+        aRet.Scale( aScaledSize, BmpScaleFlag::BestQuality );
+    }
+    else
+    {
+        imgposX = (aStandardSize - imgOldWidth) / 2 + 0.5;
+        imgposY = (aStandardSize - imgOldHeight) / 2 + 0.5;
+    }
+
+    Size aStdSize( aStandardSize, aStandardSize );
+    tools::Rectangle aRect(aEmptyPoint, aStdSize );
+
+    ScopedVclPtrInstance< VirtualDevice > aVirDevice(*Application::GetDefaultDevice());
+    aVirDevice->SetOutputSizePixel( aStdSize );
+    aVirDevice->SetFillColor( COL_TRANSPARENT );
+    aVirDevice->SetLineColor( COL_TRANSPARENT );
+
+    // Draw a rect into virDevice
+    aVirDevice->DrawRect( aRect );
+    Point aPointPixel( static_cast<tools::Long>(imgposX), static_cast<tools::Long>(imgposY) );
+    aVirDevice->DrawBitmapEx( aPointPixel, aRet );
+    aRet = aVirDevice->GetBitmapEx( aEmptyPoint, aStdSize );
+
+    return aRet;
+}
+
+sal_uInt8 BitmapEx::GetAlpha(sal_Int32 nX, sal_Int32 nY) const
+{
+    if(maBitmap.IsEmpty())
+        return 0;
+
+    if (nX < 0 || nX >= GetSizePixel().Width() || nY < 0 || nY >= GetSizePixel().Height())
+        return 0;
+
+    if (maBitmap.getPixelFormat() == vcl::PixelFormat::N32_BPP)
+        return GetPixelColor(nX, nY).GetAlpha();
+
+    sal_uInt8 nAlpha(0);
+    if (maAlphaMask.IsEmpty())
+    {
+        // Not transparent, ergo all covered
+        nAlpha = 255;
+    }
+    else
+    {
+        BitmapScopedReadAccess pRead(maAlphaMask);
+        if(pRead)
+        {
+            const BitmapColor aBitmapColor(pRead->GetPixel(nY, nX));
+            nAlpha = aBitmapColor.GetIndex();
+        }
+    }
+    return nAlpha;
+}
+
+
+Color BitmapEx::GetPixelColor(sal_Int32 nX, sal_Int32 nY) const
+{
+    BitmapScopedReadAccess pReadAccess( maBitmap );
+    assert(pReadAccess);
+
+    BitmapColor aColor = pReadAccess->GetColor(nY, nX);
+
+    if (IsAlpha())
+    {
+        AlphaMask aAlpha = GetAlphaMask();
+        BitmapScopedReadAccess pAlphaReadAccess(aAlpha);
+        aColor.SetAlpha(pAlphaReadAccess->GetPixel(nY, nX).GetIndex());
+    }
+    else if (maBitmap.getPixelFormat() != vcl::PixelFormat::N32_BPP)
+    {
+        aColor.SetAlpha(255);
+    }
+    return aColor;
+}
+
+// Shift alpha transparent pixels between cppcanvas/ implementations
+// and vcl in a generally grotesque and under-performing fashion
+bool BitmapEx::Create( const css::uno::Reference< css::rendering::XBitmapCanvas > &xBitmapCanvas,
+                       const Size &rSize )
+{
+    uno::Reference< beans::XFastPropertySet > xFastPropertySet( xBitmapCanvas, uno::UNO_QUERY );
+    if( xFastPropertySet )
+    {
+        // 0 means get BitmapEx
+        uno::Any aAny = xFastPropertySet->getFastPropertyValue( 0 );
+        std::unique_ptr<BitmapEx> xBitmapEx(reinterpret_cast<BitmapEx*>(*o3tl::doAccess<sal_Int64>(aAny)));
+        if( xBitmapEx )
+        {
+            *this = *xBitmapEx;
+            return true;
+        }
+    }
+
+    std::shared_ptr<SalBitmap> pSalBmp;
+    std::shared_ptr<SalBitmap> pSalMask;
+
+    pSalBmp = ImplGetSVData()->mpDefInst->CreateSalBitmap();
+
+    Size aLocalSize(rSize);
+    if( pSalBmp->Create( xBitmapCanvas, aLocalSize ) )
+    {
+        pSalMask = ImplGetSVData()->mpDefInst->CreateSalBitmap();
+        if ( pSalMask->Create( xBitmapCanvas, aLocalSize, true ) )
+        {
+            *this = BitmapEx(Bitmap(pSalBmp), Bitmap(pSalMask) );
+            return true;
+        }
+        else
+        {
+            *this = BitmapEx(Bitmap(pSalBmp));
+            return true;
+        }
+    }
+
+    return false;
+}
+
+namespace
+{
+    Bitmap impTransformBitmap(
+        const Bitmap& rSource,
+        const Size& rDestinationSize,
+        const basegfx::B2DHomMatrix& rTransform,
+        bool bSmooth)
+    {
+        Bitmap aDestination(rDestinationSize, vcl::PixelFormat::N24_BPP);
+        BitmapScopedWriteAccess xWrite(aDestination);
+
+        if(xWrite)
+        {
+            BitmapScopedReadAccess xRead(rSource);
+
+            if (xRead)
+            {
+                const Size aDestinationSizePixel(aDestination.GetSizePixel());
+
+                // tdf#157795 set color to black outside of bitmap bounds
+                // Due to commit 81994cb2b8b32453a92bcb011830fcb884f22ff3,
+                // transparent areas are now black instead of white.
+                const BitmapColor aOutside(0x0, 0x0, 0x0);
+
+                for(tools::Long y(0); y < aDestinationSizePixel.getHeight(); y++)
+                {
+                    Scanline pScanline = xWrite->GetScanline( y );
+                    for(tools::Long x(0); x < aDestinationSizePixel.getWidth(); x++)
+                    {
+                        const basegfx::B2DPoint aSourceCoor(rTransform * basegfx::B2DPoint(x, y));
+
+                        if(bSmooth)
+                        {
+                            xWrite->SetPixelOnData(
+                                pScanline,
+                                x,
+                                xRead->GetInterpolatedColorWithFallback(
+                                    aSourceCoor.getY(),
+                                    aSourceCoor.getX(),
+                                    aOutside));
+                        }
+                        else
+                        {
+                            // this version does the correct <= 0.0 checks, so no need
+                            // to do the static_cast< sal_Int32 > self and make an error
+                            xWrite->SetPixelOnData(
+                                pScanline,
+                                x,
+                                xRead->GetColorWithFallback(
+                                    aSourceCoor.getY(),
+                                    aSourceCoor.getX(),
+                                    aOutside));
+                        }
+                    }
+                }
+            }
+        }
+        xWrite.reset();
+
+        rSource.AdaptBitCount(aDestination);
+
+        return aDestination;
+    }
+
+    /// Decides if rTransformation needs smoothing or not (e.g. 180 deg rotation doesn't need it).
+    bool implTransformNeedsSmooth(const basegfx::B2DHomMatrix& rTransformation)
+    {
+        basegfx::B2DVector aScale, aTranslate;
+        double fRotate, fShearX;
+        rTransformation.decompose(aScale, aTranslate, fRotate, fShearX);
+        if (aScale != basegfx::B2DVector(1, 1))
+        {
+            return true;
+        }
+
+        fRotate = fmod( fRotate, 2 * M_PI );
+        if (fRotate < 0)
+        {
+            fRotate += 2 * M_PI;
+        }
+        if (!rtl::math::approxEqual(fRotate, 0)
+            && !rtl::math::approxEqual(fRotate, M_PI_2)
+            && !rtl::math::approxEqual(fRotate, M_PI)
+            && !rtl::math::approxEqual(fRotate, 3 * M_PI_2))
+        {
+            return true;
+        }
+
+        if (!rtl::math::approxEqual(fShearX, 0))
+        {
+            return true;
+        }
+
+        return false;
+    }
+} // end of anonymous namespace
+
+BitmapEx BitmapEx::TransformBitmapEx(
+    double fWidth,
+    double fHeight,
+    const basegfx::B2DHomMatrix& rTransformation) const
+{
+    if(fWidth <= 1 || fHeight <= 1)
+        return BitmapEx();
+
+    // force destination to 24 bit, we want to smooth output
+    const Size aDestinationSize(basegfx::fround(fWidth), basegfx::fround(fHeight));
+    bool bSmooth = implTransformNeedsSmooth(rTransformation);
+    const Bitmap aDestination(impTransformBitmap(GetBitmap(), aDestinationSize, rTransformation, bSmooth));
+
+    // create mask
+    if(IsAlpha())
+    {
+        const Bitmap aAlpha(impTransformBitmap(GetAlphaMask().GetBitmap(), aDestinationSize, rTransformation, bSmooth));
+        return BitmapEx(aDestination, AlphaMask(aAlpha));
+    }
+
+    return BitmapEx(aDestination);
+}
+
+BitmapEx BitmapEx::getTransformed(
+    const basegfx::B2DHomMatrix& rTransformation,
+    const basegfx::B2DRange& rVisibleRange,
+    double fMaximumArea) const
+{
+    BitmapEx aRetval;
+
+    if(IsEmpty())
+        return aRetval;
+
+    const sal_uInt32 nSourceWidth(GetSizePixel().Width());
+    const sal_uInt32 nSourceHeight(GetSizePixel().Height());
+
+    if(!nSourceWidth || !nSourceHeight)
+        return aRetval;
+
+    // Get aOutlineRange
+    basegfx::B2DRange aOutlineRange(0.0, 0.0, 1.0, 1.0);
+
+    aOutlineRange.transform(rTransformation);
+
+    // create visible range from it by moving from relative to absolute
+    basegfx::B2DRange aVisibleRange(rVisibleRange);
+
+    aVisibleRange.transform(
+        basegfx::utils::createScaleTranslateB2DHomMatrix(
+            aOutlineRange.getRange(),
+            aOutlineRange.getMinimum()));
+
+    // get target size (which is visible range's size)
+    double fWidth(aVisibleRange.getWidth());
+    double fHeight(aVisibleRange.getHeight());
+
+    if(fWidth < 1.0 || fHeight < 1.0)
+    {
+        return aRetval;
+    }
+
+    // test if discrete size (pixel) maybe too big and limit it
+    const double fArea(fWidth * fHeight);
+    const bool bNeedToReduce(basegfx::fTools::more(fArea, fMaximumArea));
+    double fReduceFactor(1.0);
+
+    if(bNeedToReduce)
+    {
+        fReduceFactor = sqrt(fMaximumArea / fArea);
+        fWidth *= fReduceFactor;
+        fHeight *= fReduceFactor;
+    }
+
+    // Build complete transform from source pixels to target pixels.
+    // Start by scaling from source pixel size to unit coordinates
+    basegfx::B2DHomMatrix aTransform(
+        basegfx::utils::createScaleB2DHomMatrix(
+            1.0 / nSourceWidth,
+            1.0 / nSourceHeight));
+
+    // multiply with given transform which leads from unit coordinates inside
+    // aOutlineRange
+    aTransform = rTransformation * aTransform;
+
+    // subtract top-left of absolute VisibleRange
+    aTransform.translate(
+        -aVisibleRange.getMinX(),
+        -aVisibleRange.getMinY());
+
+    // scale to target pixels (if needed)
+    if(bNeedToReduce)
+    {
+        aTransform.scale(fReduceFactor, fReduceFactor);
+    }
+
+    // invert to get transformation from target pixel coordinates to source pixels
+    aTransform.invert();
+
+    // create bitmap using source, destination and linear back-transformation
+    aRetval = TransformBitmapEx(fWidth, fHeight, aTransform);
+
+    return aRetval;
+}
+
+BitmapEx BitmapEx::ModifyBitmapEx(const basegfx::BColorModifierStack& rBColorModifierStack) const
+{
+    Bitmap aChangedBitmap(GetBitmap());
+    bool bDone(false);
+
+    for(sal_uInt32 a(rBColorModifierStack.count()); a && !bDone; )
+    {
+        const basegfx::BColorModifierSharedPtr& rModifier = rBColorModifierStack.getBColorModifier(--a);
+        const basegfx::BColorModifier_replace* pReplace = dynamic_cast< const basegfx::BColorModifier_replace* >(rModifier.get());
+
+        if(pReplace)
+        {
+            // complete replace
+            if(IsAlpha())
+            {
+                // clear bitmap with dest color
+                if (vcl::isPalettePixelFormat(aChangedBitmap.getPixelFormat()))
+                {
+                    // For e.g. 8bit Bitmaps, the nearest color to the given erase color is
+                    // determined and used -> this may be different from what is wanted here.
+                    // Better create a new bitmap with the needed color explicitly.
+                    BitmapScopedReadAccess xReadAccess(aChangedBitmap);
+                    OSL_ENSURE(xReadAccess, "Got no Bitmap ReadAccess ?!?");
+
+                    if(xReadAccess)
+                    {
+                        BitmapPalette aNewPalette(xReadAccess->GetPalette());
+                        aNewPalette[0] = BitmapColor(Color(pReplace->getBColor()));
+                        aChangedBitmap = Bitmap(
+                            aChangedBitmap.GetSizePixel(),
+                            aChangedBitmap.getPixelFormat(),
+                            &aNewPalette);
+                    }
+                }
+                aChangedBitmap.Erase(Color(pReplace->getBColor()));
+            }
+            else
+            {
+                // erase bitmap, caller will know to paint direct
+                aChangedBitmap.SetEmpty();
+            }
+
+            bDone = true;
+        }
+        else
+        {
+            BitmapScopedWriteAccess xContent(aChangedBitmap);
+
+            if(xContent)
+            {
+                const double fConvertColor(1.0 / 255.0);
+
+                if(xContent->HasPalette())
+                {
+                    const sal_uInt16 nCount(xContent->GetPaletteEntryCount());
+
+                    for(sal_uInt16 b(0); b < nCount; b++)
+                    {
+                        const BitmapColor& rCol = xContent->GetPaletteColor(b);
+                        const basegfx::BColor aBSource(
+                            rCol.GetRed() * fConvertColor,
+                            rCol.GetGreen() * fConvertColor,
+                            rCol.GetBlue() * fConvertColor);
+                        const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
+                        xContent->SetPaletteColor(b, BitmapColor(Color(aBDest)));
+                    }
+                }
+                else if(ScanlineFormat::N24BitTcBgr == xContent->GetScanlineFormat())
+                {
+                    for(tools::Long y(0); y < xContent->Height(); y++)
+                    {
+                        Scanline pScan = xContent->GetScanline(y);
+
+                        for(tools::Long x(0); x < xContent->Width(); x++)
+                        {
+                            const basegfx::BColor aBSource(
+                                *(pScan + 2)* fConvertColor,
+                                *(pScan + 1) * fConvertColor,
+                                *pScan * fConvertColor);
+                            const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
+                            *pScan++ = static_cast< sal_uInt8 >(aBDest.getBlue() * 255.0);
+                            *pScan++ = static_cast< sal_uInt8 >(aBDest.getGreen() * 255.0);
+                            *pScan++ = static_cast< sal_uInt8 >(aBDest.getRed() * 255.0);
+                        }
+                    }
+                }
+                else if(ScanlineFormat::N24BitTcRgb == xContent->GetScanlineFormat())
+                {
+                    for(tools::Long y(0); y < xContent->Height(); y++)
+                    {
+                        Scanline pScan = xContent->GetScanline(y);
+
+                        for(tools::Long x(0); x < xContent->Width(); x++)
+                        {
+                            const basegfx::BColor aBSource(
+                                *pScan * fConvertColor,
+                                *(pScan + 1) * fConvertColor,
+                                *(pScan + 2) * fConvertColor);
+                            const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
+                            *pScan++ = static_cast< sal_uInt8 >(aBDest.getRed() * 255.0);
+                            *pScan++ = static_cast< sal_uInt8 >(aBDest.getGreen() * 255.0);
+                            *pScan++ = static_cast< sal_uInt8 >(aBDest.getBlue() * 255.0);
+                        }
+                    }
+                }
+                else
+                {
+                    for(tools::Long y(0); y < xContent->Height(); y++)
+                    {
+                        Scanline pScanline = xContent->GetScanline( y );
+                        for(tools::Long x(0); x < xContent->Width(); x++)
+                        {
+                            const BitmapColor aBMCol(xContent->GetColor(y, x));
+                            const basegfx::BColor aBSource(
+                                static_cast<double>(aBMCol.GetRed()) * fConvertColor,
+                                static_cast<double>(aBMCol.GetGreen()) * fConvertColor,
+                                static_cast<double>(aBMCol.GetBlue()) * fConvertColor);
+                            const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource));
+
+                            xContent->SetPixelOnData(pScanline, x, BitmapColor(Color(aBDest)));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if(aChangedBitmap.IsEmpty())
+    {
+        return BitmapEx();
+    }
+    else
+    {
+        if(IsAlpha())
+        {
+            return BitmapEx(aChangedBitmap, GetAlphaMask());
+        }
+        else
+        {
+            return BitmapEx(aChangedBitmap);
+        }
+    }
+}
+
+BitmapEx createBlendFrame(
+    const Size& rSize,
+    sal_uInt8 nAlpha,
+    Color aColorTopLeft,
+    Color aColorBottomRight)
+{
+    const sal_uInt32 nW(rSize.Width());
+    const sal_uInt32 nH(rSize.Height());
+
+    if(nW || nH)
+    {
+        Color aColTopRight(aColorTopLeft);
+        Color aColBottomLeft(aColorTopLeft);
+        const sal_uInt32 nDE(nW + nH);
+
+        aColTopRight.Merge(aColorBottomRight, 255 - sal_uInt8((nW * 255) / nDE));
+        aColBottomLeft.Merge(aColorBottomRight, 255 - sal_uInt8((nH * 255) / nDE));
+
+        return createBlendFrame(rSize, nAlpha, aColorTopLeft, aColTopRight, aColorBottomRight, aColBottomLeft);
+    }
+
+    return BitmapEx();
+}
+
+BitmapEx createBlendFrame(
+    const Size& rSize,
+    sal_uInt8 nAlpha,
+    Color aColorTopLeft,
+    Color aColorTopRight,
+    Color aColorBottomRight,
+    Color aColorBottomLeft)
+{
+    // FIXME the call sites are actually passing in transparency
+    nAlpha = 255 - nAlpha;
+    BlendFrameCache* pBlendFrameCache = ImplGetBlendFrameCache();
+
+    if(pBlendFrameCache->m_aLastSize == rSize
+        && pBlendFrameCache->m_nLastAlpha == nAlpha
+        && pBlendFrameCache->m_aLastColorTopLeft == aColorTopLeft
+        && pBlendFrameCache->m_aLastColorTopRight == aColorTopRight
+        && pBlendFrameCache->m_aLastColorBottomRight == aColorBottomRight
+        && pBlendFrameCache->m_aLastColorBottomLeft == aColorBottomLeft)
+    {
+        return pBlendFrameCache->m_aLastResult;
+    }
+
+    pBlendFrameCache->m_aLastSize = rSize;
+    pBlendFrameCache->m_nLastAlpha = nAlpha;
+    pBlendFrameCache->m_aLastColorTopLeft = aColorTopLeft;
+    pBlendFrameCache->m_aLastColorTopRight = aColorTopRight;
+    pBlendFrameCache->m_aLastColorBottomRight = aColorBottomRight;
+    pBlendFrameCache->m_aLastColorBottomLeft = aColorBottomLeft;
+    pBlendFrameCache->m_aLastResult.Clear();
+
+    const tools::Long nW(rSize.Width());
+    const tools::Long nH(rSize.Height());
+
+    if(nW > 1 && nH > 1)
+    {
+        sal_uInt8 aEraseTrans(0xff);
+        Bitmap aContent(rSize, vcl::PixelFormat::N24_BPP);
+        AlphaMask aAlpha(rSize, &aEraseTrans);
+
+        aContent.Erase(COL_BLACK);
+
+        BitmapScopedWriteAccess pContent(aContent);
+        BitmapScopedWriteAccess pAlpha(aAlpha);
+
+        if(pContent && pAlpha)
+        {
+            tools::Long x(0);
+            tools::Long y(0);
+            Scanline pScanContent = pContent->GetScanline( 0 );
+            Scanline pScanAlpha = pContent->GetScanline( 0 );
+
+            // x == 0, y == 0, top-left corner
+            pContent->SetPixelOnData(pScanContent, 0, aColorTopLeft);
+            pAlpha->SetPixelOnData(pScanAlpha, 0, BitmapColor(nAlpha));
+
+            // y == 0, top line left to right
+            for(x = 1; x < nW - 1; x++)
+            {
+                Color aMix(aColorTopLeft);
+
+                aMix.Merge(aColorTopRight, 255 - sal_uInt8((x * 255) / nW));
+                pContent->SetPixelOnData(pScanContent, x, aMix);
+                pAlpha->SetPixelOnData(pScanAlpha, x, BitmapColor(nAlpha));
+            }
+
+            // x == nW - 1, y == 0, top-right corner
+            // #i123690# Caution! When nW is 1, x == nW is possible (!)
+            if(x < nW)
+            {
+                pContent->SetPixelOnData(pScanContent, x, aColorTopRight);
+                pAlpha->SetPixelOnData(pScanAlpha, x, BitmapColor(nAlpha));
+            }
+
+            // x == 0 and nW - 1, left and right line top-down
+            for(y = 1; y < nH - 1; y++)
+            {
+                pScanContent = pContent->GetScanline( y );
+                pScanAlpha = pContent->GetScanline( y );
+                Color aMixA(aColorTopLeft);
+
+                aMixA.Merge(aColorBottomLeft, 255 - sal_uInt8((y * 255) / nH));
+                pContent->SetPixelOnData(pScanContent, 0, aMixA);
+                pAlpha->SetPixelOnData(pScanAlpha, 0, BitmapColor(nAlpha));
+
+                // #i123690# Caution! When nW is 1, x == nW is possible (!)
+                if(x < nW)
+                {
+                    Color aMixB(aColorTopRight);
+
+                    aMixB.Merge(aColorBottomRight, 255 - sal_uInt8((y * 255) / nH));
+                    pContent->SetPixelOnData(pScanContent, x, aMixB);
+                    pAlpha->SetPixelOnData(pScanAlpha, x, BitmapColor(nAlpha));
+                }
+            }
+
+            // #i123690# Caution! When nH is 1, y == nH is possible (!)
+            if(y < nH)
+            {
+                // x == 0, y == nH - 1, bottom-left corner
+                pContent->SetPixelOnData(pScanContent, 0, aColorBottomLeft);
+                pAlpha->SetPixelOnData(pScanAlpha, 0, BitmapColor(nAlpha));
+
+                // y == nH - 1, bottom line left to right
+                for(x = 1; x < nW - 1; x++)
+                {
+                    Color aMix(aColorBottomLeft);
+
+                    aMix.Merge(aColorBottomRight, 255 - sal_uInt8(((x - 0)* 255) / nW));
+                    pContent->SetPixelOnData(pScanContent, x, aMix);
+                    pAlpha->SetPixelOnData(pScanAlpha, x, BitmapColor(nAlpha));
+                }
+
+                // x == nW - 1, y == nH - 1, bottom-right corner
+                // #i123690# Caution! When nW is 1, x == nW is possible (!)
+                if(x < nW)
+                {
+                    pContent->SetPixelOnData(pScanContent, x, aColorBottomRight);
+                    pAlpha->SetPixelOnData(pScanAlpha, x, BitmapColor(nAlpha));
+                }
+            }
+
+            pContent.reset();
+            pAlpha.reset();
+
+            pBlendFrameCache->m_aLastResult = BitmapEx(aContent, aAlpha);
+        }
+    }
+
+    return pBlendFrameCache->m_aLastResult;
+}
+
+void BitmapEx::Replace(const Color& rSearchColor,
+                           const Color& rReplaceColor,
+                           sal_uInt8 nTolerance)
+{
+    maBitmap.Replace(rSearchColor, rReplaceColor, nTolerance);
+}
+
+void BitmapEx::Replace( const Color* pSearchColors,
+                        const Color* pReplaceColors,
+                        size_t nColorCount,
+                        sal_uInt8 const * pTols )
+{
+    maBitmap.Replace( pSearchColors, pReplaceColors, nColorCount, pTols );
+}
+
+void BitmapEx::ReplaceTransparency(const Color& rColor)
+{
+    if( IsAlpha() )
+    {
+        maBitmap.Replace( GetAlphaMask(), rColor );
+        maAlphaMask = Bitmap();
+        maBitmapSize = maBitmap.GetSizePixel();
+    }
+}
+
+static Bitmap DetectEdges( const Bitmap& rBmp )
+{
+    constexpr sal_uInt8 cEdgeDetectThreshold = 128;
+    const Size  aSize( rBmp.GetSizePixel() );
+
+    if( ( aSize.Width() <= 2 ) || ( aSize.Height() <= 2 ) )
+        return rBmp;
+
+    Bitmap aWorkBmp( rBmp );
+
+    if( !aWorkBmp.Convert( BmpConversion::N8BitGreys ) )
+        return rBmp;
+
+    ScopedVclPtr<VirtualDevice> pVirDev(VclPtr<VirtualDevice>::Create());
+    pVirDev->SetOutputSizePixel(aSize);
+    BitmapScopedReadAccess pReadAcc(aWorkBmp);
+    if( !pReadAcc )
+        return rBmp;
+
+    const tools::Long          nWidth = aSize.Width();
+    const tools::Long          nWidth2 = nWidth - 2;
+    const tools::Long          nHeight = aSize.Height();
+    const tools::Long          nHeight2 = nHeight - 2;
+    const tools::Long          lThres2 = static_cast<tools::Long>(cEdgeDetectThreshold) * cEdgeDetectThreshold;
+    tools::Long                nSum1;
+    tools::Long                nSum2;
+    tools::Long                lGray;
+
+    // initialize border with white pixels
+    pVirDev->SetLineColor( COL_WHITE );
+    pVirDev->DrawLine( Point(), Point( nWidth - 1, 0L ) );
+    pVirDev->DrawLine( Point( nWidth - 1, 0L ), Point( nWidth - 1, nHeight - 1 ) );
+    pVirDev->DrawLine( Point( nWidth - 1, nHeight - 1 ), Point( 0L, nHeight - 1 ) );
+    pVirDev->DrawLine( Point( 0, nHeight - 1 ), Point() );
+
+    for( tools::Long nY = 0, nY1 = 1, nY2 = 2; nY < nHeight2; nY++, nY1++, nY2++ )
+    {
+        Scanline pScanlineRead = pReadAcc->GetScanline( nY );
+        Scanline pScanlineRead1 = pReadAcc->GetScanline( nY1 );
+        Scanline pScanlineRead2 = pReadAcc->GetScanline( nY2 );
+        for( tools::Long nX = 0, nXDst = 1, nXTmp; nX < nWidth2; nX++, nXDst++ )
+        {
+            nXTmp = nX;
+
+            nSum2 = pReadAcc->GetIndexFromData( pScanlineRead, nXTmp++ );
+            nSum1 = -nSum2;
+            nSum2 += static_cast<tools::Long>(pReadAcc->GetIndexFromData( pScanlineRead, nXTmp++ )) << 1;
+            lGray = pReadAcc->GetIndexFromData( pScanlineRead, nXTmp );
+            nSum1 += lGray;
+            nSum2 += lGray;
+
+            nSum1 += static_cast<tools::Long>(pReadAcc->GetIndexFromData( pScanlineRead1, nXTmp )) << 1;
+            nXTmp -= 2;
+            nSum1 -= static_cast<tools::Long>(pReadAcc->GetIndexFromData( pScanlineRead1, nXTmp )) << 1;
+
+            lGray = -static_cast<tools::Long>(pReadAcc->GetIndexFromData( pScanlineRead2, nXTmp++ ));
+            nSum1 += lGray;
+            nSum2 += lGray;
+            nSum2 -= static_cast<tools::Long>(pReadAcc->GetIndexFromData( pScanlineRead2, nXTmp++ )) << 1;
+            lGray = static_cast<tools::Long>(pReadAcc->GetIndexFromData( pScanlineRead2, nXTmp ));
+            nSum1 += lGray;
+            nSum2 -= lGray;
+
+            if( ( nSum1 * nSum1 + nSum2 * nSum2 ) < lThres2 )
+                pVirDev->DrawPixel( Point(nXDst, nY), COL_WHITE );
+            else
+                pVirDev->DrawPixel( Point(nXDst, nY), COL_BLACK );
+        }
+    }
+
+    pReadAcc.reset();
+
+    Bitmap aRetBmp = pVirDev->GetBitmap(Point(0,0), aSize);
+
+    if( aRetBmp.IsEmpty() )
+        aRetBmp = rBmp;
+    else
+    {
+        aRetBmp.SetPrefMapMode( rBmp.GetPrefMapMode() );
+        aRetBmp.SetPrefSize( rBmp.GetPrefSize() );
+    }
+
+    return aRetBmp;
+}
+
+/** Get contours in image */
+tools::Polygon  BitmapEx::GetContour( bool bContourEdgeDetect,
+                                    const tools::Rectangle* pWorkRectPixel )
+{
+    Bitmap aWorkBmp;
+    tools::Polygon aRetPoly;
+    tools::Rectangle   aWorkRect( Point(), maBitmap.GetSizePixel() );
+
+    if( pWorkRectPixel )
+        aWorkRect.Intersection( *pWorkRectPixel );
+
+    aWorkRect.Normalize();
+
+    if( ( aWorkRect.GetWidth() > 4 ) && ( aWorkRect.GetHeight() > 4 ) )
+    {
+        // if the flag is set, we need to detect edges
+        if( bContourEdgeDetect )
+            aWorkBmp = DetectEdges( maBitmap );
+        else
+            aWorkBmp = maBitmap;
+
+        BitmapScopedReadAccess pAcc(aWorkBmp);
+
+        const tools::Long nWidth = pAcc ? pAcc->Width() : 0;
+        const tools::Long nHeight = pAcc ? pAcc->Height() : 0;
+
+        if (pAcc && nWidth && nHeight)
+        {
+            const Size&         rPrefSize = aWorkBmp.GetPrefSize();
+            const double        fFactorX = static_cast<double>(rPrefSize.Width()) / nWidth;
+            const double        fFactorY = static_cast<double>(rPrefSize.Height()) / nHeight;
+            const tools::Long          nStartX1 = aWorkRect.Left() + 1;
+            const tools::Long          nEndX1 = aWorkRect.Right();
+            const tools::Long          nStartX2 = nEndX1 - 1;
+            const tools::Long          nStartY1 = aWorkRect.Top() + 1;
+            const tools::Long          nEndY1 = aWorkRect.Bottom();
+            std::unique_ptr<Point[]> pPoints1;
+            std::unique_ptr<Point[]> pPoints2;
+            tools::Long                nX, nY;
+            sal_uInt16              nPolyPos = 0;
+            const BitmapColor   aBlack = pAcc->GetBestMatchingColor( COL_BLACK );
+
+            pPoints1.reset(new Point[ nHeight ]);
+            pPoints2.reset(new Point[ nHeight ]);
+
+            for ( nY = nStartY1; nY < nEndY1; nY++ )
+            {
+                nX = nStartX1;
+                Scanline pScanline = pAcc->GetScanline( nY );
+
+                // scan row from left to right
+                while( nX < nEndX1 )
+                {
+                    if( aBlack == pAcc->GetPixelFromData( pScanline, nX ) )
+                    {
+                        pPoints1[ nPolyPos ] = Point( nX, nY );
+                        nX = nStartX2;
+
+                        // this loop always breaks eventually as there is at least one pixel
+                        while( true )
+                        {
+                            if( aBlack == pAcc->GetPixelFromData( pScanline, nX ) )
+                            {
+                                pPoints2[ nPolyPos ] = Point( nX, nY );
+                                break;
+                            }
+
+                            nX--;
+                        }
+
+                        nPolyPos++;
+                        break;
+                    }
+
+                    nX++;
+                }
+            }
+
+            const sal_uInt16 nNewSize1 = nPolyPos << 1;
+
+            aRetPoly = tools::Polygon( nPolyPos, pPoints1.get() );
+            aRetPoly.SetSize( nNewSize1 + 1 );
+            aRetPoly[ nNewSize1 ] = aRetPoly[ 0 ];
+
+            for( sal_uInt16 j = nPolyPos; nPolyPos < nNewSize1; )
+                aRetPoly[ nPolyPos++ ] = pPoints2[ --j ];
+
+            if( ( fFactorX != 0. ) && ( fFactorY != 0. ) )
+                aRetPoly.Scale( fFactorX, fFactorY );
+        }
+    }
+
+    return aRetPoly;
+}
+
+void BitmapEx::ChangeColorAlpha( sal_uInt8 cIndexFrom, sal_Int8 nAlphaTo )
+{
+    AlphaMask aAlphaMask(GetAlphaMask());
+    BitmapScopedWriteAccess pAlphaWriteAccess(aAlphaMask);
+    BitmapScopedReadAccess pReadAccess(maBitmap);
+    assert( pReadAccess.get() && pAlphaWriteAccess.get() );
+    if ( !(pReadAccess.get() && pAlphaWriteAccess.get()) )
+        return;
+
+    for ( tools::Long nY = 0; nY < pReadAccess->Height(); nY++ )
+    {
+        Scanline pScanline = pAlphaWriteAccess->GetScanline( nY );
+        Scanline pScanlineRead = pReadAccess->GetScanline( nY );
+        for ( tools::Long nX = 0; nX < pReadAccess->Width(); nX++ )
+        {
+            const sal_uInt8 cIndex = pReadAccess->GetPixelFromData( pScanlineRead, nX ).GetIndex();
+            if ( cIndex == cIndexFrom )
+                pAlphaWriteAccess->SetPixelOnData( pScanline, nX, BitmapColor(nAlphaTo) );
+        }
+    }
+    *this = BitmapEx( GetBitmap(), aAlphaMask );
+}
+
+void BitmapEx::AdjustTransparency(sal_uInt8 cTrans)
+{
+    AlphaMask   aAlpha;
+
+    if (!IsAlpha())
+    {
+        aAlpha = AlphaMask(GetSizePixel(), &cTrans);
+    }
+    else
+    {
+        aAlpha = GetAlphaMask();
+        BitmapScopedWriteAccess pA(aAlpha);
+        assert(pA);
+
+        if( !pA )
+            return;
+
+        sal_uLong nTrans = cTrans;
+        const tools::Long  nWidth = pA->Width(), nHeight = pA->Height();
+
+        if( pA->GetScanlineFormat() == ScanlineFormat::N8BitPal )
+        {
+            for( tools::Long nY = 0; nY < nHeight; nY++ )
+            {
+                Scanline pAScan = pA->GetScanline( nY );
+
+                for( tools::Long nX = 0; nX < nWidth; nX++ )
+                {
+                    sal_uLong nNewTrans = nTrans + (255 - *pAScan);
+                    // clamp to 255
+                    nNewTrans = ( nNewTrans & 0xffffff00 ) ? 255 : nNewTrans;
+                    *pAScan++ = static_cast<sal_uInt8>( 255 - nNewTrans );
+                }
+            }
+        }
+        else
+        {
+            BitmapColor aAlphaValue( 0 );
+
+            for( tools::Long nY = 0; nY < nHeight; nY++ )
+            {
+                Scanline pScanline = pA->GetScanline( nY );
+                for( tools::Long nX = 0; nX < nWidth; nX++ )
+                {
+                    sal_uLong nNewTrans = nTrans + (255 - pA->GetIndexFromData( pScanline, nX ));
+                    // clamp to 255
+                    nNewTrans = ( nNewTrans & 0xffffff00 ) ? 255 : nNewTrans;
+                    // convert back to alpha
+                    aAlphaValue.SetIndex( static_cast<sal_uInt8>(255 - nNewTrans) );
+                    pA->SetPixelOnData( pScanline, nX, aAlphaValue );
+                }
+            }
+        }
+    }
+    *this = BitmapEx( GetBitmap(), aAlpha );
+}
+
+void BitmapEx::CombineMaskOr(Color maskColor, sal_uInt8 nTol)
+{
+    AlphaMask aNewMask = maBitmap.CreateAlphaMask( maskColor, nTol );
+    if ( IsAlpha() )
+         aNewMask.AlphaCombineOr( maAlphaMask );
+    maAlphaMask = aNewMask;
+}
+
+/**
+ * Retrieves the color model data we need for the XImageConsumer stuff.
+ */
+void  BitmapEx::GetColorModel(css::uno::Sequence< sal_Int32 >& rRGBPalette,
+        sal_uInt32& rnRedMask, sal_uInt32& rnGreenMask, sal_uInt32& rnBlueMask, sal_uInt32& rnAlphaMask, sal_uInt32& rnTransparencyIndex,
+        sal_uInt32& rnWidth, sal_uInt32& rnHeight, sal_uInt8& rnBitCount)
+{
+    BitmapScopedReadAccess pReadAccess( maBitmap );
+    assert( pReadAccess );
+
+    if( pReadAccess->HasPalette() )
+    {
+        sal_uInt16 nPalCount = pReadAccess->GetPaletteEntryCount();
+
+        if( nPalCount )
+        {
+            rRGBPalette = css::uno::Sequence< sal_Int32 >( nPalCount + 1 );
+
+            sal_Int32* pTmp = rRGBPalette.getArray();
+
+            for( sal_uInt32 i = 0; i < nPalCount; i++, pTmp++ )
+            {
+                const BitmapColor& rCol = pReadAccess->GetPaletteColor( static_cast<sal_uInt16>(i) );
+
+                *pTmp = static_cast<sal_Int32>(rCol.GetRed()) << sal_Int32(24);
+                *pTmp |= static_cast<sal_Int32>(rCol.GetGreen()) << sal_Int32(16);
+                *pTmp |= static_cast<sal_Int32>(rCol.GetBlue()) << sal_Int32(8);
+                *pTmp |= sal_Int32(0x000000ffL);
+            }
+
+            if( IsAlpha() )
+            {
+                // append transparent entry
+                *pTmp = sal_Int32(0xffffff00L);
+                rnTransparencyIndex = nPalCount;
+                nPalCount++;
+            }
+            else
+                rnTransparencyIndex = 0;
+        }
+    }
+    else
+    {
+        rnRedMask = 0xff000000UL;
+        rnGreenMask = 0x00ff0000UL;
+        rnBlueMask = 0x0000ff00UL;
+        rnAlphaMask = 0x000000ffUL;
+        rnTransparencyIndex = 0;
+    }
+
+    rnWidth = pReadAccess->Width();
+    rnHeight = pReadAccess->Height();
+    rnBitCount = pReadAccess->GetBitCount();
+}
+
+void BitmapEx::DumpAsPng(const char* pFileName) const
+{
+    OUString sPath;
+    if (pFileName)
+    {
+        sPath = OUString::fromUtf8(pFileName);
+    }
+    else if (const char* pEnv = std::getenv("VCL_DUMP_BMP_PATH"))
+    {
+        sPath = OUString::fromUtf8(pEnv);
+    }
+    else
+    {
+        sPath = "file:///tmp/bitmap.png";
+    }
+    SvFileStream aStream(sPath, StreamMode::STD_READWRITE | StreamMode::TRUNC);
+    assert(aStream.good());
+    vcl::PngImageWriter aWriter(aStream);
+    aWriter.write(*this);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapFastScaleFilter.cxx b/vcl/source/bitmap/BitmapFastScaleFilter.cxx
new file mode 100644
index 0000000000..431211369f
--- /dev/null
+++ b/vcl/source/bitmap/BitmapFastScaleFilter.cxx
@@ -0,0 +1,129 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/log.hxx>
+#include <tools/helpers.hxx>
+
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+#include <bitmap/BitmapFastScaleFilter.hxx>
+
+BitmapEx BitmapFastScaleFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    SAL_INFO("vcl.gdi", "BitmapFastScaleFilter::execute()");
+
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+    const Size aSizePix(aBitmap.GetSizePixel());
+    const sal_Int32 nNewWidth = FRound(aSizePix.Width() * mfScaleX);
+    const sal_Int32 nNewHeight = FRound(aSizePix.Height() * mfScaleY);
+    bool bRet = false;
+
+    SAL_INFO("vcl.gdi", "New width: " << nNewWidth << "\nNew height: " << nNewHeight);
+
+    if (nNewWidth > 0 && nNewHeight > 0)
+    {
+        BitmapScopedReadAccess pReadAcc(aBitmap);
+
+        if (pReadAcc)
+        {
+            Bitmap aNewBmp(Size(nNewWidth, nNewHeight), aBitmap.getPixelFormat(),
+                           &pReadAcc->GetPalette());
+            BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+
+            if (pWriteAcc)
+            {
+                const sal_Int32 nScanlineSize = pWriteAcc->GetScanlineSize();
+                const sal_Int32 nNewHeight1 = nNewHeight - 1;
+
+                if (nNewWidth && nNewHeight)
+                {
+                    const double nWidth = pReadAcc->Width();
+                    const double nHeight = pReadAcc->Height();
+                    std::unique_ptr<sal_Int32[]> pLutX(new sal_Int32[nNewWidth]);
+                    std::unique_ptr<sal_Int32[]> pLutY(new sal_Int32[nNewHeight]);
+
+                    for (sal_Int32 nX = 0; nX < nNewWidth; nX++)
+                    {
+                        pLutX[nX] = sal_Int32(nX * nWidth / nNewWidth);
+                    }
+
+                    for (sal_Int32 nY = 0; nY < nNewHeight; nY++)
+                    {
+                        pLutY[nY] = sal_Int32(nY * nHeight / nNewHeight);
+                    }
+
+                    sal_Int32 nActY = 0;
+                    while (nActY < nNewHeight)
+                    {
+                        sal_Int32 nMapY = pLutY[nActY];
+                        Scanline pScanline = pWriteAcc->GetScanline(nActY);
+                        Scanline pScanlineRead = pReadAcc->GetScanline(nMapY);
+
+                        for (sal_Int32 nX = 0; nX < nNewWidth; nX++)
+                        {
+                            pWriteAcc->SetPixelOnData(
+                                pScanline, nX,
+                                pReadAcc->GetPixelFromData(pScanlineRead, pLutX[nX]));
+                        }
+
+                        while ((nActY < nNewHeight1) && (pLutY[nActY + 1] == nMapY))
+                        {
+                            memcpy(pWriteAcc->GetScanline(nActY + 1), pWriteAcc->GetScanline(nActY),
+                                   nScanlineSize);
+                            nActY++;
+                        }
+                        nActY++;
+                    }
+
+                    bRet = true;
+                }
+
+                pWriteAcc.reset();
+            }
+            pReadAcc.reset();
+
+            if (bRet)
+            {
+                aBitmap.ReassignWithSize(aNewBmp);
+                SAL_INFO("vcl.gdi", "Bitmap size: " << aBitmap.GetSizePixel());
+            }
+            else
+            {
+                SAL_WARN("vcl.gdi", "no resize");
+            }
+        }
+    }
+
+    AlphaMask aMask(rBitmapEx.GetAlphaMask());
+
+    if (bRet && !aMask.IsEmpty())
+        bRet = aMask.Scale(maSize, BmpScaleFlag::Fast);
+
+    SAL_WARN_IF(!aMask.IsEmpty() && aBitmap.GetSizePixel() != aMask.GetSizePixel(), "vcl",
+                "BitmapEx::Scale(): size mismatch for bitmap and alpha mask.");
+
+    if (bRet)
+        return BitmapEx(aBitmap, aMask);
+
+    return BitmapEx();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapFilterStackBlur.cxx b/vcl/source/bitmap/BitmapFilterStackBlur.cxx
new file mode 100644
index 0000000000..6e3b1ef555
--- /dev/null
+++ b/vcl/source/bitmap/BitmapFilterStackBlur.cxx
@@ -0,0 +1,658 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <vcl/BitmapFilterStackBlur.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+#include <sal/log.hxx>
+
+#include <comphelper/threadpool.hxx>
+
+namespace
+{
+const sal_Int16 constMultiplyTable[255]
+    = { 512, 512, 456, 512, 328, 456, 335, 512, 405, 328, 271, 456, 388, 335, 292, 512, 454,
+        405, 364, 328, 298, 271, 496, 456, 420, 388, 360, 335, 312, 292, 273, 512, 482, 454,
+        428, 405, 383, 364, 345, 328, 312, 298, 284, 271, 259, 496, 475, 456, 437, 420, 404,
+        388, 374, 360, 347, 335, 323, 312, 302, 292, 282, 273, 265, 512, 497, 482, 468, 454,
+        441, 428, 417, 405, 394, 383, 373, 364, 354, 345, 337, 328, 320, 312, 305, 298, 291,
+        284, 278, 271, 265, 259, 507, 496, 485, 475, 465, 456, 446, 437, 428, 420, 412, 404,
+        396, 388, 381, 374, 367, 360, 354, 347, 341, 335, 329, 323, 318, 312, 307, 302, 297,
+        292, 287, 282, 278, 273, 269, 265, 261, 512, 505, 497, 489, 482, 475, 468, 461, 454,
+        447, 441, 435, 428, 422, 417, 411, 405, 399, 394, 389, 383, 378, 373, 368, 364, 359,
+        354, 350, 345, 341, 337, 332, 328, 324, 320, 316, 312, 309, 305, 301, 298, 294, 291,
+        287, 284, 281, 278, 274, 271, 268, 265, 262, 259, 257, 507, 501, 496, 491, 485, 480,
+        475, 470, 465, 460, 456, 451, 446, 442, 437, 433, 428, 424, 420, 416, 412, 408, 404,
+        400, 396, 392, 388, 385, 381, 377, 374, 370, 367, 363, 360, 357, 354, 350, 347, 344,
+        341, 338, 335, 332, 329, 326, 323, 320, 318, 315, 312, 310, 307, 304, 302, 299, 297,
+        294, 292, 289, 287, 285, 282, 280, 278, 275, 273, 271, 269, 267, 265, 263, 261, 259 };
+
+const sal_Int16 constShiftTable[255]
+    = { 9,  11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17,
+        18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+        19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21,
+        21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+        21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+        22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23,
+        23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+        23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+        23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+        24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+        24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+        24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24 };
+
+struct BlurSharedData
+{
+    BitmapReadAccess* mpReadAccess;
+    BitmapWriteAccess* mpWriteAccess;
+    sal_Int32 mnRadius;
+    sal_Int32 mnComponentWidth;
+    sal_Int32 mnDiv;
+    sal_Int32 mnColorChannels;
+
+    BlurSharedData(BitmapReadAccess* pReadAccess, BitmapWriteAccess* pWriteAccess,
+                   sal_Int32 aRadius, sal_Int32 nComponentWidth, sal_Int32 nColorChannels)
+        : mpReadAccess(pReadAccess)
+        , mpWriteAccess(pWriteAccess)
+        , mnRadius(aRadius)
+        , mnComponentWidth(nComponentWidth)
+        , mnDiv(aRadius + aRadius + 1)
+        , mnColorChannels(nColorChannels)
+    {
+    }
+};
+
+struct BlurArrays
+{
+    BlurSharedData maShared;
+
+    std::vector<sal_uInt8> maStackBuffer;
+    std::vector<sal_Int32> maPositionTable;
+    std::vector<sal_Int32> maWeightTable;
+
+    std::vector<sal_Int32> mnSumVector;
+    std::vector<sal_Int32> mnInSumVector;
+    std::vector<sal_Int32> mnOutSumVector;
+
+    BlurArrays(BlurSharedData const& rShared)
+        : maShared(rShared)
+        , maStackBuffer(maShared.mnDiv * maShared.mnComponentWidth)
+        , maPositionTable(maShared.mnDiv)
+        , maWeightTable(maShared.mnDiv)
+        , mnSumVector(maShared.mnColorChannels)
+        , mnInSumVector(maShared.mnColorChannels)
+        , mnOutSumVector(maShared.mnColorChannels)
+    {
+    }
+
+    void initializeWeightAndPositions(sal_Int32 nLastIndex)
+    {
+        for (sal_Int32 i = 0; i < maShared.mnDiv; i++)
+        {
+            maPositionTable[i] = std::clamp(i - maShared.mnRadius, sal_Int32(0), nLastIndex);
+            maWeightTable[i] = maShared.mnRadius + 1 - std::abs(i - maShared.mnRadius);
+        }
+    }
+
+    sal_Int32 getMultiplyValue() const
+    {
+        return static_cast<sal_Int32>(constMultiplyTable[maShared.mnRadius]);
+    }
+
+    sal_Int32 getShiftValue() const
+    {
+        return static_cast<sal_Int32>(constShiftTable[maShared.mnRadius]);
+    }
+};
+
+typedef void (*BlurRangeFn)(BlurSharedData const& rShared, sal_Int32 nStartY, sal_Int32 nEndY);
+
+class BlurTask : public comphelper::ThreadTask
+{
+    BlurRangeFn mpBlurFunction;
+    BlurSharedData& mrShared;
+    sal_Int32 mnStartY;
+    sal_Int32 mnEndY;
+
+public:
+    explicit BlurTask(const std::shared_ptr<comphelper::ThreadTaskTag>& pTag,
+                      BlurRangeFn pBlurFunction, BlurSharedData& rShared, sal_Int32 nStartY,
+                      sal_Int32 nEndY)
+        : comphelper::ThreadTask(pTag)
+        , mpBlurFunction(pBlurFunction)
+        , mrShared(rShared)
+        , mnStartY(nStartY)
+        , mnEndY(nEndY)
+    {
+    }
+
+    virtual void doWork() override { mpBlurFunction(mrShared, mnStartY, mnEndY); }
+};
+
+struct SumFunction24
+{
+    static inline void add(sal_Int32*& pValue1, sal_Int32 nConstant)
+    {
+        pValue1[0] += nConstant;
+        pValue1[1] += nConstant;
+        pValue1[2] += nConstant;
+    }
+
+    static inline void set(sal_Int32*& pValue1, sal_Int32 nConstant)
+    {
+        pValue1[0] = nConstant;
+        pValue1[1] = nConstant;
+        pValue1[2] = nConstant;
+    }
+
+    static inline void add(sal_Int32*& pValue1, const sal_uInt8* pValue2)
+    {
+        pValue1[0] += pValue2[0];
+        pValue1[1] += pValue2[1];
+        pValue1[2] += pValue2[2];
+    }
+
+    static inline void add(sal_Int32*& pValue1, const sal_Int32* pValue2)
+    {
+        pValue1[0] += pValue2[0];
+        pValue1[1] += pValue2[1];
+        pValue1[2] += pValue2[2];
+    }
+
+    static inline void sub(sal_Int32*& pValue1, const sal_uInt8* pValue2)
+    {
+        pValue1[0] -= pValue2[0];
+        pValue1[1] -= pValue2[1];
+        pValue1[2] -= pValue2[2];
+    }
+
+    static inline void sub(sal_Int32*& pValue1, const sal_Int32* pValue2)
+    {
+        pValue1[0] -= pValue2[0];
+        pValue1[1] -= pValue2[1];
+        pValue1[2] -= pValue2[2];
+    }
+
+    static inline void assignPtr(sal_uInt8*& pValue1, const sal_uInt8* pValue2)
+    {
+        pValue1[0] = pValue2[0];
+        pValue1[1] = pValue2[1];
+        pValue1[2] = pValue2[2];
+    }
+
+    static inline void assignMulAndShr(sal_uInt8*& result, const sal_Int32* sum, sal_Int32 multiply,
+                                       sal_Int32 shift)
+    {
+        result[0] = (multiply * sum[0]) >> shift;
+        result[1] = (multiply * sum[1]) >> shift;
+        result[2] = (multiply * sum[2]) >> shift;
+    }
+};
+
+struct SumFunction8
+{
+    static inline void add(sal_Int32*& pValue1, sal_Int32 nConstant) { pValue1[0] += nConstant; }
+
+    static inline void set(sal_Int32*& pValue1, sal_Int32 nConstant) { pValue1[0] = nConstant; }
+
+    static inline void add(sal_Int32*& pValue1, const sal_uInt8* pValue2)
+    {
+        pValue1[0] += pValue2[0];
+    }
+
+    static inline void add(sal_Int32*& pValue1, const sal_Int32* pValue2)
+    {
+        pValue1[0] += pValue2[0];
+    }
+
+    static inline void sub(sal_Int32*& pValue1, const sal_uInt8* pValue2)
+    {
+        pValue1[0] -= pValue2[0];
+    }
+
+    static inline void sub(sal_Int32*& pValue1, const sal_Int32* pValue2)
+    {
+        pValue1[0] -= pValue2[0];
+    }
+
+    static inline void assignPtr(sal_uInt8*& pValue1, const sal_uInt8* pValue2)
+    {
+        pValue1[0] = pValue2[0];
+    }
+
+    static inline void assignMulAndShr(sal_uInt8*& result, const sal_Int32* sum, sal_Int32 multiply,
+                                       sal_Int32 shift)
+    {
+        result[0] = (multiply * sum[0]) >> shift;
+    }
+};
+
+template <typename SumFunction>
+void stackBlurHorizontal(BlurSharedData const& rShared, sal_Int32 nStart, sal_Int32 nEnd)
+{
+    BitmapReadAccess* pReadAccess = rShared.mpReadAccess;
+    BitmapWriteAccess* pWriteAccess = rShared.mpWriteAccess;
+
+    BlurArrays aArrays(rShared);
+
+    sal_uInt8* pStack = aArrays.maStackBuffer.data();
+    sal_uInt8* pStackPtr;
+
+    sal_Int32 nWidth = pReadAccess->Width();
+    sal_Int32 nLastIndexX = nWidth - 1;
+
+    sal_Int32 nMultiplyValue = aArrays.getMultiplyValue();
+    sal_Int32 nShiftValue = aArrays.getShiftValue();
+
+    sal_Int32 nRadius = rShared.mnRadius;
+    sal_Int32 nComponentWidth = rShared.mnComponentWidth;
+    sal_Int32 nDiv = rShared.mnDiv;
+
+    Scanline pSourcePointer;
+    Scanline pDestinationPointer;
+
+    sal_Int32 nXPosition;
+    sal_Int32 nStackIndex;
+    sal_Int32 nStackIndexStart;
+    sal_Int32 nWeight;
+
+    aArrays.initializeWeightAndPositions(nLastIndexX);
+
+    sal_Int32* nSum = aArrays.mnSumVector.data();
+    sal_Int32* nInSum = aArrays.mnInSumVector.data();
+    sal_Int32* nOutSum = aArrays.mnOutSumVector.data();
+
+    sal_Int32* pPositionPointer = aArrays.maPositionTable.data();
+    sal_Int32* pWeightPointer = aArrays.maWeightTable.data();
+
+    for (sal_Int32 y = nStart; y <= nEnd; y++)
+    {
+        SumFunction::set(nSum, 0);
+        SumFunction::set(nInSum, 0);
+        SumFunction::set(nOutSum, 0);
+
+        // Pre-initialize blur data for first pixel.
+        // aArrays.maPositionTable contains values like (for radius of 5): [0,0,0,0,0,0,1,2,3,4,5],
+        // which are used as pixels indices in the current row that we use to prepare information
+        // for the first pixel; aArrays.maWeightTable has [1,2,3,4,5,6,5,4,3,2,1]. Before looking at
+        // the first row pixel, we pretend to have processed fake previous pixels, as if the row was
+        // extended to the left with the same color as that of the first pixel.
+        for (sal_Int32 i = 0; i < nDiv; i++)
+        {
+            pSourcePointer = pReadAccess->GetScanline(y) + nComponentWidth * pPositionPointer[i];
+
+            pStackPtr = &pStack[nComponentWidth * i];
+
+            SumFunction::assignPtr(pStackPtr, pSourcePointer);
+
+            nWeight = pWeightPointer[i];
+
+            SumFunction::add(nSum, pSourcePointer[0] * nWeight);
+
+            if (i - nRadius > 0)
+            {
+                SumFunction::add(nInSum, pSourcePointer);
+            }
+            else
+            {
+                SumFunction::add(nOutSum, pSourcePointer);
+            }
+        }
+
+        nStackIndex = nRadius;
+        nXPosition = std::min(nRadius, nLastIndexX);
+
+        pSourcePointer = pReadAccess->GetScanline(y) + nComponentWidth * nXPosition;
+
+        for (sal_Int32 x = 0; x < nWidth; x++)
+        {
+            pDestinationPointer = pWriteAccess->GetScanline(y) + nComponentWidth * x;
+
+            SumFunction::assignMulAndShr(pDestinationPointer, nSum, nMultiplyValue, nShiftValue);
+
+            SumFunction::sub(nSum, nOutSum);
+
+            nStackIndexStart = nStackIndex + nDiv - nRadius;
+            if (nStackIndexStart >= nDiv)
+            {
+                nStackIndexStart -= nDiv;
+            }
+            pStackPtr = &pStack[nComponentWidth * nStackIndexStart];
+
+            SumFunction::sub(nOutSum, pStackPtr);
+
+            if (nXPosition < nLastIndexX)
+            {
+                nXPosition++;
+                pSourcePointer = pReadAccess->GetScanline(y) + nComponentWidth * nXPosition;
+            }
+
+            SumFunction::assignPtr(pStackPtr, pSourcePointer);
+
+            SumFunction::add(nInSum, pSourcePointer);
+
+            SumFunction::add(nSum, nInSum);
+
+            nStackIndex++;
+            if (nStackIndex >= nDiv)
+            {
+                nStackIndex = 0;
+            }
+
+            pStackPtr = &pStack[nStackIndex * nComponentWidth];
+
+            SumFunction::add(nOutSum, pStackPtr);
+            SumFunction::sub(nInSum, pStackPtr);
+        }
+    }
+}
+
+template <typename SumFunction>
+void stackBlurVertical(BlurSharedData const& rShared, sal_Int32 nStart, sal_Int32 nEnd)
+{
+    BitmapReadAccess* pReadAccess = rShared.mpReadAccess;
+    BitmapWriteAccess* pWriteAccess = rShared.mpWriteAccess;
+
+    BlurArrays aArrays(rShared);
+
+    sal_uInt8* pStack = aArrays.maStackBuffer.data();
+    sal_uInt8* pStackPtr;
+
+    sal_Int32 nHeight = pReadAccess->Height();
+    sal_Int32 nLastIndexY = nHeight - 1;
+
+    sal_Int32 nMultiplyValue = aArrays.getMultiplyValue();
+    sal_Int32 nShiftValue = aArrays.getShiftValue();
+
+    sal_Int32 nRadius = rShared.mnRadius;
+    sal_Int32 nComponentWidth = rShared.mnComponentWidth;
+    sal_Int32 nDiv = rShared.mnDiv;
+
+    Scanline pSourcePointer;
+    Scanline pDestinationPointer;
+
+    sal_Int32 nYPosition;
+    sal_Int32 nStackIndex;
+    sal_Int32 nStackIndexStart;
+    sal_Int32 nWeight;
+
+    aArrays.initializeWeightAndPositions(nLastIndexY);
+
+    sal_Int32* nSum = aArrays.mnSumVector.data();
+    sal_Int32* nInSum = aArrays.mnInSumVector.data();
+    sal_Int32* nOutSum = aArrays.mnOutSumVector.data();
+    sal_Int32* pPositionPointer = aArrays.maPositionTable.data();
+    sal_Int32* pWeightPointer = aArrays.maWeightTable.data();
+
+    for (sal_Int32 x = nStart; x <= nEnd; x++)
+    {
+        SumFunction::set(nSum, 0);
+        SumFunction::set(nInSum, 0);
+        SumFunction::set(nOutSum, 0);
+
+        // Pre-initialize blur data for first pixel.
+        // aArrays.maPositionTable contains values like (for radius of 5): [0,0,0,0,0,0,1,2,3,4,5],
+        // which are used as pixels indices in the current column that we use to prepare information
+        // for the first pixel; aArrays.maWeightTable has [1,2,3,4,5,6,5,4,3,2,1]. Before looking at
+        // the first column pixels, we pretend to have processed fake previous pixels, as if the
+        // column was extended to the top with the same color as that of the first pixel.
+        for (sal_Int32 i = 0; i < nDiv; i++)
+        {
+            pSourcePointer = pReadAccess->GetScanline(pPositionPointer[i]) + nComponentWidth * x;
+
+            pStackPtr = &pStack[nComponentWidth * i];
+
+            SumFunction::assignPtr(pStackPtr, pSourcePointer);
+
+            nWeight = pWeightPointer[i];
+
+            SumFunction::add(nSum, pSourcePointer[0] * nWeight);
+
+            if (i - nRadius > 0)
+            {
+                SumFunction::add(nInSum, pSourcePointer);
+            }
+            else
+            {
+                SumFunction::add(nOutSum, pSourcePointer);
+            }
+        }
+
+        nStackIndex = nRadius;
+        nYPosition = std::min(nRadius, nLastIndexY);
+
+        pSourcePointer = pReadAccess->GetScanline(nYPosition) + nComponentWidth * x;
+
+        for (sal_Int32 y = 0; y < nHeight; y++)
+        {
+            pDestinationPointer = pWriteAccess->GetScanline(y) + nComponentWidth * x;
+
+            SumFunction::assignMulAndShr(pDestinationPointer, nSum, nMultiplyValue, nShiftValue);
+
+            SumFunction::sub(nSum, nOutSum);
+
+            nStackIndexStart = nStackIndex + nDiv - nRadius;
+            if (nStackIndexStart >= nDiv)
+            {
+                nStackIndexStart -= nDiv;
+            }
+            pStackPtr = &pStack[nComponentWidth * nStackIndexStart];
+
+            SumFunction::sub(nOutSum, pStackPtr);
+
+            if (nYPosition < nLastIndexY)
+            {
+                nYPosition++;
+                pSourcePointer = pReadAccess->GetScanline(nYPosition) + nComponentWidth * x;
+            }
+
+            SumFunction::assignPtr(pStackPtr, pSourcePointer);
+            SumFunction::add(nInSum, pSourcePointer);
+            SumFunction::add(nSum, nInSum);
+
+            nStackIndex++;
+            if (nStackIndex >= nDiv)
+            {
+                nStackIndex = 0;
+            }
+
+            pStackPtr = &pStack[nStackIndex * nComponentWidth];
+
+            SumFunction::add(nOutSum, pStackPtr);
+            SumFunction::sub(nInSum, pStackPtr);
+        }
+    }
+}
+
+constexpr sal_Int32 nThreadStrip = 16;
+
+void runStackBlur(Bitmap& rBitmap, const sal_Int32 nRadius, const sal_Int32 nComponentWidth,
+                  const sal_Int32 nColorChannels, BlurRangeFn pBlurHorizontalFn,
+                  BlurRangeFn pBlurVerticalFn, const bool bParallel)
+{
+    if (bParallel)
+    {
+        try
+        {
+            comphelper::ThreadPool& rShared = comphelper::ThreadPool::getSharedOptimalPool();
+            auto pTag = comphelper::ThreadPool::createThreadTaskTag();
+
+            {
+                BitmapScopedReadAccess pReadAccess(rBitmap);
+                BitmapScopedWriteAccess pWriteAccess(rBitmap);
+                BlurSharedData aSharedData(pReadAccess.get(), pWriteAccess.get(), nRadius,
+                                           nComponentWidth, nColorChannels);
+
+                const sal_Int32 nFirstIndex = 0;
+                const sal_Int32 nLastIndex = pReadAccess->Height() - 1;
+
+                vcl::bitmap::generateStripRanges<nThreadStrip>(
+                    nFirstIndex, nLastIndex,
+                    [&](sal_Int32 const nStart, sal_Int32 const nEnd, bool const bLast) {
+                        if (!bLast)
+                        {
+                            auto pTask(std::make_unique<BlurTask>(pTag, pBlurHorizontalFn,
+                                                                  aSharedData, nStart, nEnd));
+                            rShared.pushTask(std::move(pTask));
+                        }
+                        else
+                            pBlurHorizontalFn(aSharedData, nStart, nEnd);
+                    });
+                rShared.waitUntilDone(pTag);
+            }
+            {
+                BitmapScopedReadAccess pReadAccess(rBitmap);
+                BitmapScopedWriteAccess pWriteAccess(rBitmap);
+                BlurSharedData aSharedData(pReadAccess.get(), pWriteAccess.get(), nRadius,
+                                           nComponentWidth, nColorChannels);
+
+                const sal_Int32 nFirstIndex = 0;
+                const sal_Int32 nLastIndex = pReadAccess->Width() - 1;
+
+                vcl::bitmap::generateStripRanges<nThreadStrip>(
+                    nFirstIndex, nLastIndex,
+                    [&](sal_Int32 const nStart, sal_Int32 const nEnd, bool const bLast) {
+                        if (!bLast)
+                        {
+                            auto pTask(std::make_unique<BlurTask>(pTag, pBlurVerticalFn,
+                                                                  aSharedData, nStart, nEnd));
+                            rShared.pushTask(std::move(pTask));
+                        }
+                        else
+                            pBlurVerticalFn(aSharedData, nStart, nEnd);
+                    });
+
+                rShared.waitUntilDone(pTag);
+            }
+        }
+        catch (...)
+        {
+            SAL_WARN("vcl.gdi", "threaded bitmap blurring failed");
+        }
+    }
+    else
+    {
+        {
+            BitmapScopedReadAccess pReadAccess(rBitmap);
+            BitmapScopedWriteAccess pWriteAccess(rBitmap);
+            BlurSharedData aSharedData(pReadAccess.get(), pWriteAccess.get(), nRadius,
+                                       nComponentWidth, nColorChannels);
+            sal_Int32 nFirstIndex = 0;
+            sal_Int32 nLastIndex = pReadAccess->Height() - 1;
+            pBlurHorizontalFn(aSharedData, nFirstIndex, nLastIndex);
+        }
+        {
+            BitmapScopedReadAccess pReadAccess(rBitmap);
+            BitmapScopedWriteAccess pWriteAccess(rBitmap);
+            BlurSharedData aSharedData(pReadAccess.get(), pWriteAccess.get(), nRadius,
+                                       nComponentWidth, nColorChannels);
+            sal_Int32 nFirstIndex = 0;
+            sal_Int32 nLastIndex = pReadAccess->Width() - 1;
+            pBlurVerticalFn(aSharedData, nFirstIndex, nLastIndex);
+        }
+    }
+}
+
+void stackBlur24(Bitmap& rBitmap, sal_Int32 nRadius, sal_Int32 nComponentWidth)
+{
+    const bool bParallel = true;
+    // Limit radius
+    nRadius = std::clamp<sal_Int32>(nRadius, 2, 254);
+    const sal_Int32 nColorChannels = 3; // 3 color channel
+
+    BlurRangeFn pBlurHorizontalFn = stackBlurHorizontal<SumFunction24>;
+    BlurRangeFn pBlurVerticalFn = stackBlurVertical<SumFunction24>;
+
+    runStackBlur(rBitmap, nRadius, nComponentWidth, nColorChannels, pBlurHorizontalFn,
+                 pBlurVerticalFn, bParallel);
+}
+
+void stackBlur8(Bitmap& rBitmap, sal_Int32 nRadius, sal_Int32 nComponentWidth)
+{
+    const bool bParallel = true;
+    // Limit radius
+    nRadius = std::clamp<sal_Int32>(nRadius, 2, 254);
+    const sal_Int32 nColorChannels = 1; // 1 color channel
+
+    BlurRangeFn pBlurHorizontalFn = stackBlurHorizontal<SumFunction8>;
+    BlurRangeFn pBlurVerticalFn = stackBlurVertical<SumFunction8>;
+
+    runStackBlur(rBitmap, nRadius, nComponentWidth, nColorChannels, pBlurHorizontalFn,
+                 pBlurVerticalFn, bParallel);
+}
+
+} // end anonymous namespace
+
+/**
+ * Implementation of stack blur - a fast Gaussian blur approximation.
+ * nRadius - blur radius, valid values are between 2 and 254
+ * bExtend - extend the bitmap in all directions by the radius
+ *
+ * Stack Blur Algorithm by Mario Klingemann <mario@quasimondo.com>
+ * (http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html)
+ *
+ * Additionally references and implementations:
+ * - Blur.js by Jacob Kelley
+ *   (http://www.blurjs.com)
+ * - BlurEffectForAndroidDesign by Nicolas Pomepuy
+ *   (https://github.com/PomepuyN/BlurEffectForAndroidDesign)
+ * - StackBluriOS by Thomas Landspurg
+ *   (https://github.com/tomsoft1/StackBluriOS)
+ * - stackblur.cpp by Benjamin Yates
+ *   (https://gist.github.com/benjamin9999/3809142)
+ * - stack blur in fog 2D graphic library by Petr Kobalicek
+ *   (https://code.google.com/p/fog/)
+ *
+ */
+BitmapFilterStackBlur::BitmapFilterStackBlur(sal_Int32 nRadius)
+    : mnRadius(nRadius)
+{
+}
+
+BitmapFilterStackBlur::~BitmapFilterStackBlur() {}
+
+BitmapEx BitmapFilterStackBlur::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap = rBitmapEx.GetBitmap();
+    Bitmap result = filter(aBitmap);
+    return BitmapEx(result, rBitmapEx.GetAlphaMask());
+}
+
+Bitmap BitmapFilterStackBlur::filter(Bitmap const& rBitmap) const
+{
+    Bitmap bitmapCopy(rBitmap);
+    ScanlineFormat nScanlineFormat;
+    {
+        BitmapScopedReadAccess pReadAccess(bitmapCopy);
+        nScanlineFormat = pReadAccess ? pReadAccess->GetScanlineFormat() : ScanlineFormat::NONE;
+    }
+
+    if (nScanlineFormat == ScanlineFormat::N24BitTcRgb
+        || nScanlineFormat == ScanlineFormat::N24BitTcBgr
+        || nScanlineFormat == ScanlineFormat::N32BitTcMask
+        || nScanlineFormat == ScanlineFormat::N32BitTcBgra)
+    {
+        int nComponentWidth = (nScanlineFormat == ScanlineFormat::N32BitTcMask
+                               || nScanlineFormat == ScanlineFormat::N32BitTcBgra)
+                                  ? 4
+                                  : 3;
+
+        stackBlur24(bitmapCopy, mnRadius, nComponentWidth);
+    }
+    else if (nScanlineFormat == ScanlineFormat::N8BitPal)
+    {
+        int nComponentWidth = 1;
+
+        stackBlur8(bitmapCopy, mnRadius, nComponentWidth);
+    }
+
+    return bitmapCopy;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapGaussianSeparableBlurFilter.cxx b/vcl/source/bitmap/BitmapGaussianSeparableBlurFilter.cxx
new file mode 100644
index 0000000000..d1bc188c95
--- /dev/null
+++ b/vcl/source/bitmap/BitmapGaussianSeparableBlurFilter.cxx
@@ -0,0 +1,215 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <tools/helpers.hxx>
+
+#include <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapGaussianSeparableBlurFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+BitmapEx BitmapGaussianSeparableBlurFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+    const sal_Int32 nWidth = aBitmap.GetSizePixel().Width();
+    const sal_Int32 nHeight = aBitmap.GetSizePixel().Height();
+
+    // Prepare Blur Vector
+    int aNumberOfContributions;
+    std::vector<double> aBlurVector(makeBlurKernel(mfRadius, aNumberOfContributions));
+    std::vector<double> aWeights;
+    std::vector<int> aPixels;
+    std::vector<int> aCounts;
+
+    // Do horizontal filtering
+    blurContributions(nWidth, aNumberOfContributions, aBlurVector, aWeights, aPixels, aCounts);
+
+    BitmapScopedReadAccess pReadAcc(aBitmap);
+
+    // switch coordinates as convolution pass transposes result
+    Bitmap aNewBitmap(Size(nHeight, nWidth), vcl::PixelFormat::N24_BPP);
+
+    bool bResult = convolutionPass(aBitmap, aNewBitmap, pReadAcc.get(), aNumberOfContributions,
+                                   aWeights.data(), aPixels.data(), aCounts.data());
+
+    // Cleanup
+    pReadAcc.reset();
+    aWeights.clear();
+    aPixels.clear();
+    aCounts.clear();
+
+    if (!bResult)
+    {
+        aBlurVector.clear();
+    }
+    else
+    {
+        // Swap current bitmap with new bitmap
+        aBitmap.ReassignWithSize(aNewBitmap);
+
+        // Do vertical filtering
+        blurContributions(nHeight, aNumberOfContributions, aBlurVector, aWeights, aPixels, aCounts);
+
+        pReadAcc = aBitmap;
+        aNewBitmap = Bitmap(Size(nWidth, nHeight), vcl::PixelFormat::N24_BPP);
+        bResult = convolutionPass(aBitmap, aNewBitmap, pReadAcc.get(), aNumberOfContributions,
+                                  aWeights.data(), aPixels.data(), aCounts.data());
+
+        // Cleanup
+        pReadAcc.reset();
+        aWeights.clear();
+        aCounts.clear();
+        aPixels.clear();
+        aBlurVector.clear();
+
+        if (bResult)
+            aBitmap.ReassignWithSize(aNewBitmap); // swap current bitmap with new bitmap
+    }
+
+    if (bResult)
+        return BitmapEx(aBitmap);
+
+    return BitmapEx();
+}
+
+bool BitmapGaussianSeparableBlurFilter::convolutionPass(const Bitmap& rBitmap, Bitmap& aNewBitmap,
+                                                        BitmapReadAccess const* pReadAcc,
+                                                        int aNumberOfContributions,
+                                                        const double* pWeights, int const* pPixels,
+                                                        const int* pCount)
+{
+    if (!pReadAcc)
+        return false;
+
+    BitmapScopedWriteAccess pWriteAcc(aNewBitmap);
+    if (!pWriteAcc)
+        return false;
+
+    const int nHeight = rBitmap.GetSizePixel().Height();
+    assert(rBitmap.GetSizePixel().Height() == aNewBitmap.GetSizePixel().Width());
+    const int nWidth = rBitmap.GetSizePixel().Width();
+    assert(rBitmap.GetSizePixel().Width() == aNewBitmap.GetSizePixel().Height());
+
+    BitmapColor aColor;
+    double aValueRed, aValueGreen, aValueBlue;
+    double aSum, aWeight;
+    int aBaseIndex, aIndex;
+
+    for (int nSourceY = 0; nSourceY < nHeight; ++nSourceY)
+    {
+        for (int nSourceX = 0; nSourceX < nWidth; ++nSourceX)
+        {
+            aBaseIndex = nSourceX * aNumberOfContributions;
+            aSum = aValueRed = aValueGreen = aValueBlue = 0.0;
+
+            for (int j = 0; j < pCount[nSourceX]; ++j)
+            {
+                aIndex = aBaseIndex + j;
+                aWeight = pWeights[aIndex];
+                aSum += aWeight;
+
+                aColor = pReadAcc->GetColor(nSourceY, pPixels[aIndex]);
+
+                aValueRed += aWeight * aColor.GetRed();
+                aValueGreen += aWeight * aColor.GetGreen();
+                aValueBlue += aWeight * aColor.GetBlue();
+            }
+
+            BitmapColor aResultColor(
+                static_cast<sal_uInt8>(std::clamp(aValueRed / aSum, 0.0, 255.0)),
+                static_cast<sal_uInt8>(std::clamp(aValueGreen / aSum, 0.0, 255.0)),
+                static_cast<sal_uInt8>(std::clamp(aValueBlue / aSum, 0.0, 255.0)));
+
+            int nDestX = nSourceY;
+            int nDestY = nSourceX;
+
+            pWriteAcc->SetPixel(nDestY, nDestX, aResultColor);
+        }
+    }
+    return true;
+}
+
+std::vector<double> BitmapGaussianSeparableBlurFilter::makeBlurKernel(const double radius,
+                                                                      int& rows)
+{
+    int intRadius = static_cast<int>(radius + 1.0);
+    rows = intRadius * 2 + 1;
+    std::vector<double> matrix(rows);
+
+    double sigma = radius / 3;
+    double radius2 = radius * radius;
+    int index = 0;
+    for (int row = -intRadius; row <= intRadius; row++)
+    {
+        double distance = row * row;
+        if (distance > radius2)
+        {
+            matrix[index] = 0.0;
+        }
+        else
+        {
+            matrix[index] = exp(-distance / (2.0 * sigma * sigma)) / sqrt(2.0 * M_PI * sigma);
+        }
+        index++;
+    }
+    return matrix;
+}
+
+void BitmapGaussianSeparableBlurFilter::blurContributions(
+    const int aSize, const int aNumberOfContributions, const std::vector<double>& rBlurVector,
+    std::vector<double>& rWeights, std::vector<int>& rPixels, std::vector<int>& rCounts)
+{
+    rWeights.resize(aSize * aNumberOfContributions);
+    rPixels.resize(aSize * aNumberOfContributions);
+    rCounts.resize(aSize);
+
+    int aLeft, aRight, aCurrentCount, aPixelIndex;
+    double aWeight;
+
+    for (int i = 0; i < aSize; i++)
+    {
+        aLeft = i - aNumberOfContributions / 2;
+        aRight = i + aNumberOfContributions / 2;
+        aCurrentCount = 0;
+        for (int j = aLeft; j <= aRight; j++)
+        {
+            aWeight = rBlurVector[aCurrentCount];
+
+            // Mirror edges
+            if (j < 0)
+            {
+                aPixelIndex = -j;
+            }
+            else if (j >= aSize)
+            {
+                aPixelIndex = (aSize - j) + aSize - 1;
+            }
+            else
+            {
+                aPixelIndex = j;
+            }
+
+            // Edge case for small bitmaps
+            if (aPixelIndex < 0 || aPixelIndex >= aSize)
+            {
+                aWeight = 0.0;
+            }
+
+            rWeights[i * aNumberOfContributions + aCurrentCount] = aWeight;
+            rPixels[i * aNumberOfContributions + aCurrentCount] = aPixelIndex;
+
+            aCurrentCount++;
+        }
+        rCounts[i] = aCurrentCount;
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapInfoAccess.cxx b/vcl/source/bitmap/BitmapInfoAccess.cxx
new file mode 100644
index 0000000000..817d5187c3
--- /dev/null
+++ b/vcl/source/bitmap/BitmapInfoAccess.cxx
@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <vcl/BitmapInfoAccess.hxx>
+
+#include <salbmp.hxx>
+#include <svdata.hxx>
+#include <salinst.hxx>
+
+BitmapInfoAccess::BitmapInfoAccess(const AlphaMask& rBitmap, BitmapAccessMode nMode)
+    : BitmapInfoAccess(rBitmap.GetBitmap(), nMode)
+{
+}
+
+BitmapInfoAccess::BitmapInfoAccess(const Bitmap& rBitmap, BitmapAccessMode nMode)
+    : mpBuffer(nullptr)
+    , mnAccessMode(nMode)
+{
+    std::shared_ptr<SalBitmap> xImpBmp = rBitmap.ImplGetSalBitmap();
+
+    if (!xImpBmp)
+        return;
+
+    if (mnAccessMode == BitmapAccessMode::Write)
+    {
+        xImpBmp->DropScaledCache();
+
+        if (xImpBmp.use_count() > 2)
+        {
+            xImpBmp.reset();
+            const_cast<Bitmap&>(rBitmap).ImplMakeUnique();
+            xImpBmp = rBitmap.ImplGetSalBitmap();
+        }
+    }
+
+    mpBuffer = xImpBmp->AcquireBuffer(mnAccessMode);
+
+    if (!mpBuffer)
+    {
+        std::shared_ptr<SalBitmap> xNewImpBmp(ImplGetSVData()->mpDefInst->CreateSalBitmap());
+        if (xNewImpBmp->Create(*xImpBmp, rBitmap.getPixelFormat()))
+        {
+            xImpBmp = xNewImpBmp;
+            const_cast<Bitmap&>(rBitmap).ImplSetSalBitmap(xImpBmp);
+            mpBuffer = xImpBmp->AcquireBuffer(mnAccessMode);
+        }
+    }
+
+    maBitmap = rBitmap;
+}
+
+BitmapInfoAccess::~BitmapInfoAccess()
+{
+    std::shared_ptr<SalBitmap> xImpBmp = maBitmap.ImplGetSalBitmap();
+
+    if (mpBuffer && xImpBmp)
+    {
+        xImpBmp->ReleaseBuffer(mpBuffer, mnAccessMode);
+    }
+}
+
+sal_uInt16 BitmapInfoAccess::GetBestPaletteIndex(const BitmapColor& rBitmapColor) const
+{
+    const BitmapBuffer* pBuffer = mpBuffer;
+
+    return (HasPalette() ? pBuffer->maPalette.GetBestIndex(rBitmapColor) : 0);
+}
+
+sal_uInt16 BitmapInfoAccess::GetMatchingPaletteIndex(const BitmapColor& rBitmapColor) const
+{
+    assert(HasPalette());
+    return mpBuffer->maPalette.GetMatchingIndex(rBitmapColor);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapInterpolateScaleFilter.cxx b/vcl/source/bitmap/BitmapInterpolateScaleFilter.cxx
new file mode 100644
index 0000000000..c0c866b53d
--- /dev/null
+++ b/vcl/source/bitmap/BitmapInterpolateScaleFilter.cxx
@@ -0,0 +1,245 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <tools/helpers.hxx>
+#include <osl/diagnose.h>
+
+#include <vcl/bitmapex.hxx>
+
+#include <vcl/BitmapWriteAccess.hxx>
+#include <bitmap/BitmapFastScaleFilter.hxx>
+#include <bitmap/BitmapInterpolateScaleFilter.hxx>
+
+BitmapEx BitmapInterpolateScaleFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+    const Size aSizePix(aBitmap.GetSizePixel());
+    const sal_Int32 nNewWidth = FRound(aSizePix.Width() * mfScaleX);
+    const sal_Int32 nNewHeight = FRound(aSizePix.Height() * mfScaleY);
+    bool bRet = false;
+
+    if ((nNewWidth > 1) && (nNewHeight > 1))
+    {
+        BitmapScopedReadAccess pReadAcc(aBitmap);
+        if (pReadAcc)
+        {
+            sal_Int32 nWidth = pReadAcc->Width();
+            sal_Int32 nHeight = pReadAcc->Height();
+            Bitmap aNewBmp(Size(nNewWidth, nHeight), vcl::PixelFormat::N24_BPP);
+            BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+
+            if (pWriteAcc)
+            {
+                if (1 == nWidth)
+                {
+                    for (sal_Int32 nY = 0; nY < nHeight; nY++)
+                    {
+                        Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+                        BitmapColor aCol0;
+                        if (pReadAcc->HasPalette())
+                        {
+                            aCol0 = pReadAcc->GetPaletteColor(
+                                pReadAcc->GetIndexFromData(pScanlineRead, 0));
+                        }
+                        else
+                        {
+                            aCol0 = pReadAcc->GetPixelFromData(pScanlineRead, 0);
+                        }
+
+                        Scanline pScanline = pWriteAcc->GetScanline(nY);
+                        for (sal_Int32 nX = 0; nX < nNewWidth; nX++)
+                        {
+                            pWriteAcc->SetPixelOnData(pScanline, nX, aCol0);
+                        }
+                    }
+                }
+                else
+                {
+                    const sal_Int32 nNewWidth1 = nNewWidth - 1;
+                    const sal_Int32 nWidth1 = pReadAcc->Width() - 1;
+                    const double fRevScaleX = static_cast<double>(nWidth1) / nNewWidth1;
+
+                    std::unique_ptr<sal_Int32[]> pLutInt(new sal_Int32[nNewWidth]);
+                    std::unique_ptr<sal_Int32[]> pLutFrac(new sal_Int32[nNewWidth]);
+
+                    for (sal_Int32 nX = 0, nTemp = nWidth - 2; nX < nNewWidth; nX++)
+                    {
+                        double fTemp = nX * fRevScaleX;
+                        pLutInt[nX]
+                            = std::clamp(static_cast<sal_Int32>(fTemp), sal_Int32(0), nTemp);
+                        fTemp -= pLutInt[nX];
+                        pLutFrac[nX] = static_cast<sal_Int32>(fTemp * 1024.);
+                    }
+
+                    for (sal_Int32 nY = 0; nY < nHeight; nY++)
+                    {
+                        Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+                        Scanline pScanline = pWriteAcc->GetScanline(nY);
+                        for (sal_Int32 nX = 0; nX < nNewWidth; nX++)
+                        {
+                            sal_Int32 nTemp = pLutInt[nX];
+
+                            BitmapColor aCol0, aCol1;
+                            if (pReadAcc->HasPalette())
+                            {
+                                aCol0 = pReadAcc->GetPaletteColor(
+                                    pReadAcc->GetIndexFromData(pScanlineRead, nTemp++));
+                                aCol1 = pReadAcc->GetPaletteColor(
+                                    pReadAcc->GetIndexFromData(pScanlineRead, nTemp));
+                            }
+                            else
+                            {
+                                aCol0 = pReadAcc->GetPixelFromData(pScanlineRead, nTemp++);
+                                aCol1 = pReadAcc->GetPixelFromData(pScanlineRead, nTemp);
+                            }
+
+                            nTemp = pLutFrac[nX];
+
+                            sal_Int32 lXR0 = aCol0.GetRed();
+                            sal_Int32 lXG0 = aCol0.GetGreen();
+                            sal_Int32 lXB0 = aCol0.GetBlue();
+                            sal_Int32 lXR1 = aCol1.GetRed() - lXR0;
+                            sal_Int32 lXG1 = aCol1.GetGreen() - lXG0;
+                            sal_Int32 lXB1 = aCol1.GetBlue() - lXB0;
+
+                            aCol0.SetRed(
+                                static_cast<sal_uInt8>((lXR1 * nTemp + (lXR0 << 10)) >> 10));
+                            aCol0.SetGreen(
+                                static_cast<sal_uInt8>((lXG1 * nTemp + (lXG0 << 10)) >> 10));
+                            aCol0.SetBlue(
+                                static_cast<sal_uInt8>((lXB1 * nTemp + (lXB0 << 10)) >> 10));
+
+                            pWriteAcc->SetPixelOnData(pScanline, nX, aCol0);
+                        }
+                    }
+                }
+
+                bRet = true;
+            }
+
+            pReadAcc.reset();
+            pWriteAcc.reset();
+
+            if (bRet)
+            {
+                bRet = false;
+                const Bitmap aOriginal(aBitmap);
+                aBitmap = aNewBmp;
+                aNewBmp = Bitmap(Size(nNewWidth, nNewHeight), vcl::PixelFormat::N24_BPP);
+                pReadAcc = aBitmap;
+                pWriteAcc = aNewBmp;
+
+                if (pReadAcc && pWriteAcc)
+                {
+                    // after 1st step, bitmap *is* 24bit format (see above)
+                    OSL_ENSURE(!pReadAcc->HasPalette(), "OOps, somehow ImplScaleInterpolate "
+                                                        "in-between format has palette, should not "
+                                                        "happen (!)");
+
+                    if (1 == nHeight)
+                    {
+                        for (sal_Int32 nX = 0; nX < nNewWidth; nX++)
+                        {
+                            BitmapColor aCol0 = pReadAcc->GetPixel(0, nX);
+
+                            for (sal_Int32 nY = 0; nY < nNewHeight; nY++)
+                            {
+                                pWriteAcc->SetPixel(nY, nX, aCol0);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        const sal_Int32 nNewHeight1 = nNewHeight - 1;
+                        const sal_Int32 nHeight1 = pReadAcc->Height() - 1;
+                        const double fRevScaleY = static_cast<double>(nHeight1) / nNewHeight1;
+
+                        std::unique_ptr<sal_Int32[]> pLutInt(new sal_Int32[nNewHeight]);
+                        std::unique_ptr<sal_Int32[]> pLutFrac(new sal_Int32[nNewHeight]);
+
+                        for (sal_Int32 nY = 0, nTemp = nHeight - 2; nY < nNewHeight; nY++)
+                        {
+                            double fTemp = nY * fRevScaleY;
+                            pLutInt[nY]
+                                = std::clamp(static_cast<sal_Int32>(fTemp), sal_Int32(0), nTemp);
+                            fTemp -= pLutInt[nY];
+                            pLutFrac[nY] = static_cast<sal_Int32>(fTemp * 1024.);
+                        }
+
+                        for (sal_Int32 nX = 0; nX < nNewWidth; nX++)
+                        {
+                            for (sal_Int32 nY = 0; nY < nNewHeight; nY++)
+                            {
+                                sal_Int32 nTemp = pLutInt[nY];
+
+                                BitmapColor aCol0 = pReadAcc->GetPixel(nTemp++, nX);
+                                BitmapColor aCol1 = pReadAcc->GetPixel(nTemp, nX);
+
+                                nTemp = pLutFrac[nY];
+
+                                sal_Int32 lXR0 = aCol0.GetRed();
+                                sal_Int32 lXG0 = aCol0.GetGreen();
+                                sal_Int32 lXB0 = aCol0.GetBlue();
+                                sal_Int32 lXR1 = aCol1.GetRed() - lXR0;
+                                sal_Int32 lXG1 = aCol1.GetGreen() - lXG0;
+                                sal_Int32 lXB1 = aCol1.GetBlue() - lXB0;
+
+                                aCol0.SetRed(
+                                    static_cast<sal_uInt8>((lXR1 * nTemp + (lXR0 << 10)) >> 10));
+                                aCol0.SetGreen(
+                                    static_cast<sal_uInt8>((lXG1 * nTemp + (lXG0 << 10)) >> 10));
+                                aCol0.SetBlue(
+                                    static_cast<sal_uInt8>((lXB1 * nTemp + (lXB0 << 10)) >> 10));
+
+                                pWriteAcc->SetPixel(nY, nX, aCol0);
+                            }
+                        }
+                    }
+
+                    bRet = true;
+                }
+
+                pReadAcc.reset();
+                pWriteAcc.reset();
+
+                if (bRet)
+                {
+                    aOriginal.AdaptBitCount(aNewBmp);
+                    aBitmap = aNewBmp;
+                }
+            }
+        }
+    }
+
+    if (!bRet)
+    {
+        // fallback to fast scale filter
+        BitmapEx aBmpEx(aBitmap);
+        bRet = BitmapFilter::Filter(aBmpEx, BitmapFastScaleFilter(mfScaleX, mfScaleY));
+        aBitmap = aBmpEx.GetBitmap();
+    }
+
+    if (bRet)
+        return BitmapEx(aBitmap);
+
+    return BitmapEx();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapLightenFilter.cxx b/vcl/source/bitmap/BitmapLightenFilter.cxx
new file mode 100644
index 0000000000..a5c4f71e63
--- /dev/null
+++ b/vcl/source/bitmap/BitmapLightenFilter.cxx
@@ -0,0 +1,67 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <basegfx/color/bcolortools.hxx>
+
+#include <vcl/BitmapWriteAccess.hxx>
+#include <bitmap/BitmapLightenFilter.hxx>
+
+BitmapEx BitmapLightenFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    const Size aSize(rBitmapEx.GetSizePixel());
+
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+    Bitmap aDarkBitmap(aSize, vcl::PixelFormat::N24_BPP);
+
+    BitmapScopedReadAccess pRead(aBitmap);
+    BitmapScopedWriteAccess pWrite(aDarkBitmap);
+
+    if (pRead && pWrite)
+    {
+        for (sal_Int32 nY = 0; nY < sal_Int32(aSize.Height()); ++nY)
+        {
+            Scanline pScanline = pWrite->GetScanline(nY);
+            Scanline pScanlineRead = pRead->GetScanline(nY);
+            for (sal_Int32 nX = 0; nX < sal_Int32(aSize.Width()); ++nX)
+            {
+                BitmapColor aBmpColor
+                    = pRead->HasPalette()
+                          ? pRead->GetPaletteColor(pRead->GetIndexFromData(pScanlineRead, nX))
+                          : pRead->GetPixelFromData(pScanlineRead, nX);
+                aBmpColor.Invert();
+                basegfx::BColor aBColor(aBmpColor.getBColor());
+                aBColor = basegfx::utils::rgb2hsl(aBColor);
+
+                double fHue = aBColor.getRed();
+                fHue += 180.0;
+
+                while (fHue > 360.0)
+                {
+                    fHue -= 360.0;
+                }
+
+                aBColor.setRed(fHue);
+
+                aBColor = basegfx::utils::hsl2rgb(aBColor);
+                aBmpColor.SetRed((aBColor.getRed() * 255.0) + 0.5);
+                aBmpColor.SetGreen((aBColor.getGreen() * 255.0) + 0.5);
+                aBmpColor.SetBlue((aBColor.getBlue() * 255.0) + 0.5);
+
+                pWrite->SetPixelOnData(pScanline, nX, aBmpColor);
+            }
+        }
+    }
+    pWrite.reset();
+    pRead.reset();
+
+    return BitmapEx(aDarkBitmap, rBitmapEx.GetAlphaMask());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapMaskToAlphaFilter.cxx b/vcl/source/bitmap/BitmapMaskToAlphaFilter.cxx
new file mode 100644
index 0000000000..acae8f516e
--- /dev/null
+++ b/vcl/source/bitmap/BitmapMaskToAlphaFilter.cxx
@@ -0,0 +1,58 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <basegfx/color/bcolortools.hxx>
+
+#include <vcl/BitmapWriteAccess.hxx>
+#include <bitmap/BitmapMaskToAlphaFilter.hxx>
+
+/**
+ * Convert a 1-bit mask to an alpha bitmap
+ */
+BitmapEx BitmapMaskToAlphaFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    const Size aSize(rBitmapEx.GetSizePixel());
+
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+    Bitmap aOutBitmap(aSize, vcl::PixelFormat::N8_BPP, &Bitmap::GetGreyPalette(256));
+
+    BitmapScopedReadAccess pRead(aBitmap);
+    BitmapScopedWriteAccess pWrite(aOutBitmap);
+
+    if (pRead && pWrite)
+    {
+        assert(pRead->HasPalette() && "only supposed to be called with 1-bit mask");
+        assert(pRead->GetPaletteEntryCount() == 2);
+        for (sal_Int32 nY = 0; nY < sal_Int32(aSize.Height()); ++nY)
+        {
+            Scanline pScanline = pWrite->GetScanline(nY);
+            Scanline pScanlineRead = pRead->GetScanline(nY);
+            for (sal_Int32 nX = 0; nX < sal_Int32(aSize.Width()); ++nX)
+            {
+                BitmapColor aBmpColor = pRead->GetPixelFromData(pScanlineRead, nX);
+                if (aBmpColor == COL_BLACK)
+                    aBmpColor = COL_ALPHA_OPAQUE;
+                else if (aBmpColor == COL_WHITE)
+                    aBmpColor = COL_ALPHA_TRANSPARENT;
+                else if (aBmpColor == Color(0, 0, 1))
+                    aBmpColor = COL_ALPHA_TRANSPARENT;
+                else
+                    assert(false);
+                pWrite->SetPixelOnData(pScanline, nX, aBmpColor);
+            }
+        }
+    }
+    pWrite.reset();
+    pRead.reset();
+
+    return BitmapEx(aOutBitmap);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapMedianFilter.cxx b/vcl/source/bitmap/BitmapMedianFilter.cxx
new file mode 100644
index 0000000000..222451d0a9
--- /dev/null
+++ b/vcl/source/bitmap/BitmapMedianFilter.cxx
@@ -0,0 +1,204 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapMedianFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+#define S2(a, b)                                                                                   \
+    {                                                                                              \
+        sal_Int32 t;                                                                               \
+        if ((t = b - a) < 0)                                                                       \
+        {                                                                                          \
+            a += t;                                                                                \
+            b -= t;                                                                                \
+        }                                                                                          \
+    }
+#define MN3(a, b, c)                                                                               \
+    S2(a, b);                                                                                      \
+    S2(a, c);
+#define MX3(a, b, c)                                                                               \
+    S2(b, c);                                                                                      \
+    S2(a, c);
+#define MNMX3(a, b, c)                                                                             \
+    MX3(a, b, c);                                                                                  \
+    S2(a, b);
+#define MNMX4(a, b, c, d)                                                                          \
+    S2(a, b);                                                                                      \
+    S2(c, d);                                                                                      \
+    S2(a, c);                                                                                      \
+    S2(b, d);
+#define MNMX5(a, b, c, d, e)                                                                       \
+    S2(a, b);                                                                                      \
+    S2(c, d);                                                                                      \
+    MN3(a, c, e);                                                                                  \
+    MX3(b, d, e);
+#define MNMX6(a, b, c, d, e, f)                                                                    \
+    S2(a, d);                                                                                      \
+    S2(b, e);                                                                                      \
+    S2(c, f);                                                                                      \
+    MN3(a, b, c);                                                                                  \
+    MX3(d, e, f);
+
+BitmapEx BitmapMedianFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+    BitmapScopedReadAccess pReadAcc(aBitmap);
+    if (!pReadAcc)
+        return BitmapEx();
+
+    Bitmap aNewBmp(aBitmap.GetSizePixel(), vcl::PixelFormat::N24_BPP);
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if (!pWriteAcc)
+        return BitmapEx();
+
+    const sal_Int32 nWidth = pWriteAcc->Width(), nWidth2 = nWidth + 2;
+    const sal_Int32 nHeight = pWriteAcc->Height(), nHeight2 = nHeight + 2;
+    std::unique_ptr<sal_Int32[]> pColm(new sal_Int32[nWidth2]);
+    std::unique_ptr<sal_Int32[]> pRows(new sal_Int32[nHeight2]);
+    std::unique_ptr<BitmapColor[]> pColRow1(new BitmapColor[nWidth2]);
+    std::unique_ptr<BitmapColor[]> pColRow2(new BitmapColor[nWidth2]);
+    std::unique_ptr<BitmapColor[]> pColRow3(new BitmapColor[nWidth2]);
+    BitmapColor* pRowTmp1 = pColRow1.get();
+    BitmapColor* pRowTmp2 = pColRow2.get();
+    BitmapColor* pRowTmp3 = pColRow3.get();
+    BitmapColor* pColor;
+    sal_Int32 nY, nX, i;
+    sal_Int32 nR1, nR2, nR3, nR4, nR5, nR6, nR7, nR8, nR9;
+    sal_Int32 nG1, nG2, nG3, nG4, nG5, nG6, nG7, nG8, nG9;
+    sal_Int32 nB1, nB2, nB3, nB4, nB5, nB6, nB7, nB8, nB9;
+
+    // create column LUT
+    for (i = 0; i < nWidth2; i++)
+        pColm[i] = (i > 0) ? (i - 1) : 0;
+
+    pColm[nWidth + 1] = pColm[nWidth];
+
+    // create row LUT
+    for (i = 0; i < nHeight2; i++)
+        pRows[i] = (i > 0) ? (i - 1) : 0;
+
+    pRows[nHeight + 1] = pRows[nHeight];
+
+    // read first three rows of bitmap color
+    if (nHeight2 > 2)
+    {
+        for (i = 0; i < nWidth2; i++)
+        {
+            pColRow1[i] = pReadAcc->GetColor(pRows[0], pColm[i]);
+            pColRow2[i] = pReadAcc->GetColor(pRows[1], pColm[i]);
+            pColRow3[i] = pReadAcc->GetColor(pRows[2], pColm[i]);
+        }
+    }
+
+    // do median filtering
+    for (nY = 0; nY < nHeight;)
+    {
+        Scanline pScanline = pWriteAcc->GetScanline(nY);
+        for (nX = 0; nX < nWidth; nX++)
+        {
+            pColor = pRowTmp1 + nX;
+            nR1 = pColor->GetRed();
+            nG1 = pColor->GetGreen();
+            nB1 = pColor->GetBlue();
+            nR2 = (++pColor)->GetRed();
+            nG2 = pColor->GetGreen();
+            nB2 = pColor->GetBlue();
+            nR3 = (++pColor)->GetRed();
+            nG3 = pColor->GetGreen();
+            nB3 = pColor->GetBlue();
+
+            pColor = pRowTmp2 + nX;
+            nR4 = pColor->GetRed();
+            nG4 = pColor->GetGreen();
+            nB4 = pColor->GetBlue();
+            nR5 = (++pColor)->GetRed();
+            nG5 = pColor->GetGreen();
+            nB5 = pColor->GetBlue();
+            nR6 = (++pColor)->GetRed();
+            nG6 = pColor->GetGreen();
+            nB6 = pColor->GetBlue();
+
+            pColor = pRowTmp3 + nX;
+            nR7 = pColor->GetRed();
+            nG7 = pColor->GetGreen();
+            nB7 = pColor->GetBlue();
+            nR8 = (++pColor)->GetRed();
+            nG8 = pColor->GetGreen();
+            nB8 = pColor->GetBlue();
+            nR9 = (++pColor)->GetRed();
+            nG9 = pColor->GetGreen();
+            nB9 = pColor->GetBlue();
+
+            MNMX6(nR1, nR2, nR3, nR4, nR5, nR6);
+            MNMX5(nR7, nR2, nR3, nR4, nR5);
+            MNMX4(nR8, nR2, nR3, nR4);
+            MNMX3(nR9, nR2, nR3);
+
+            MNMX6(nG1, nG2, nG3, nG4, nG5, nG6);
+            MNMX5(nG7, nG2, nG3, nG4, nG5);
+            MNMX4(nG8, nG2, nG3, nG4);
+            MNMX3(nG9, nG2, nG3);
+
+            MNMX6(nB1, nB2, nB3, nB4, nB5, nB6);
+            MNMX5(nB7, nB2, nB3, nB4, nB5);
+            MNMX4(nB8, nB2, nB3, nB4);
+            MNMX3(nB9, nB2, nB3);
+
+            // set destination color
+            pWriteAcc->SetPixelOnData(pScanline, nX,
+                                      BitmapColor(static_cast<sal_uInt8>(nR2),
+                                                  static_cast<sal_uInt8>(nG2),
+                                                  static_cast<sal_uInt8>(nB2)));
+        }
+
+        if (++nY < nHeight)
+        {
+            if (pRowTmp1 == pColRow1.get())
+            {
+                pRowTmp1 = pColRow2.get();
+                pRowTmp2 = pColRow3.get();
+                pRowTmp3 = pColRow1.get();
+            }
+            else if (pRowTmp1 == pColRow2.get())
+            {
+                pRowTmp1 = pColRow3.get();
+                pRowTmp2 = pColRow1.get();
+                pRowTmp3 = pColRow2.get();
+            }
+            else
+            {
+                pRowTmp1 = pColRow1.get();
+                pRowTmp2 = pColRow2.get();
+                pRowTmp3 = pColRow3.get();
+            }
+
+            for (i = 0; i < nWidth2; i++)
+                pRowTmp3[i] = pReadAcc->GetColor(pRows[nY + 2], pColm[i]);
+        }
+    }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+
+    const MapMode aMap(aBitmap.GetPrefMapMode());
+    const Size aPrefSize(aBitmap.GetPrefSize());
+
+    aBitmap = aNewBmp;
+
+    aBitmap.SetPrefMapMode(aMap);
+    aBitmap.SetPrefSize(aPrefSize);
+
+    return BitmapEx(aBitmap);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapMonochromeFilter.cxx b/vcl/source/bitmap/BitmapMonochromeFilter.cxx
new file mode 100644
index 0000000000..00f7b99ef1
--- /dev/null
+++ b/vcl/source/bitmap/BitmapMonochromeFilter.cxx
@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapMonochromeFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+BitmapEx BitmapMonochromeFilter::execute(BitmapEx const& aBitmapEx) const
+{
+    Bitmap aBitmap = aBitmapEx.GetBitmap();
+    BitmapScopedReadAccess pReadAcc(aBitmap);
+    if (!pReadAcc)
+        return BitmapEx();
+
+    Bitmap aNewBmp(aBitmap.GetSizePixel(), vcl::PixelFormat::N8_BPP, &Bitmap::GetGreyPalette(256));
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if (!pWriteAcc)
+        return BitmapEx();
+
+    const BitmapColor aBlack(pWriteAcc->GetBestMatchingColor(COL_BLACK));
+    const BitmapColor aWhite(pWriteAcc->GetBestMatchingColor(COL_WHITE));
+    const sal_Int32 nWidth = pWriteAcc->Width();
+    const sal_Int32 nHeight = pWriteAcc->Height();
+
+    if (pReadAcc->HasPalette())
+    {
+        for (sal_Int32 nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+            for (sal_Int32 nX = 0; nX < nWidth; nX++)
+            {
+                const sal_uInt8 cIndex = pReadAcc->GetIndexFromData(pScanlineRead, nX);
+                if (pReadAcc->GetPaletteColor(cIndex).GetLuminance() >= mcThreshold)
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aWhite);
+                }
+                else
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aBlack);
+                }
+            }
+        }
+    }
+    else
+    {
+        for (sal_Int32 nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+            for (sal_Int32 nX = 0; nX < nWidth; nX++)
+            {
+                if (pReadAcc->GetPixelFromData(pScanlineRead, nX).GetLuminance() >= mcThreshold)
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aWhite);
+                }
+                else
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aBlack);
+                }
+            }
+        }
+    }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+
+    const MapMode aMap(aBitmap.GetPrefMapMode());
+    const Size aSize(aBitmap.GetPrefSize());
+
+    aBitmap = aNewBmp;
+
+    aBitmap.SetPrefMapMode(aMap);
+    aBitmap.SetPrefSize(aSize);
+
+    return BitmapEx(aBitmap);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapMosaicFilter.cxx b/vcl/source/bitmap/BitmapMosaicFilter.cxx
new file mode 100644
index 0000000000..0f89b23b9a
--- /dev/null
+++ b/vcl/source/bitmap/BitmapMosaicFilter.cxx
@@ -0,0 +1,183 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapMosaicFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+BitmapEx BitmapMosaicFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+    bool bRet = false;
+
+    if (mnTileWidth > 1 || mnTileHeight > 1)
+    {
+        std::optional<Bitmap> pNewBmp;
+        BitmapScopedReadAccess pReadAcc;
+        BitmapScopedWriteAccess pWriteAcc;
+
+        if (!isPalettePixelFormat(aBitmap.getPixelFormat()))
+        {
+            pReadAcc = aBitmap;
+            pWriteAcc = aBitmap;
+        }
+        else
+        {
+            pNewBmp.emplace(aBitmap.GetSizePixel(), vcl::PixelFormat::N24_BPP);
+            pReadAcc = aBitmap;
+            pWriteAcc = *pNewBmp;
+        }
+
+        bool bConditionsMet = false;
+        sal_Int32 nWidth(0);
+        sal_Int32 nHeight(0);
+        if (pReadAcc && pWriteAcc)
+        {
+            nWidth = pReadAcc->Width();
+            nHeight = pReadAcc->Height();
+            bConditionsMet = (nWidth > 0 && nHeight > 0);
+        }
+
+        if (bConditionsMet)
+        {
+            BitmapColor aCol;
+            sal_Int32 nX, nY, nX1, nX2, nY1, nY2, nSumR, nSumG, nSumB;
+            double fArea_1;
+
+            nY1 = 0;
+            nY2 = mnTileHeight - 1;
+
+            if (nY2 >= nHeight)
+                nY2 = nHeight - 1;
+
+            do
+            {
+                nX1 = 0;
+                nX2 = mnTileWidth - 1;
+
+                if (nX2 >= nWidth)
+                    nX2 = nWidth - 1;
+
+                fArea_1 = 1.0 / ((nX2 - nX1 + 1) * (nY2 - nY1 + 1));
+
+                if (!pNewBmp)
+                {
+                    do
+                    {
+                        for (nY = nY1, nSumR = nSumG = nSumB = 0; nY <= nY2; nY++)
+                        {
+                            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+                            for (nX = nX1; nX <= nX2; nX++)
+                            {
+                                aCol = pReadAcc->GetPixelFromData(pScanlineRead, nX);
+                                nSumR += aCol.GetRed();
+                                nSumG += aCol.GetGreen();
+                                nSumB += aCol.GetBlue();
+                            }
+                        }
+
+                        aCol.SetRed(static_cast<sal_uInt8>(nSumR * fArea_1));
+                        aCol.SetGreen(static_cast<sal_uInt8>(nSumG * fArea_1));
+                        aCol.SetBlue(static_cast<sal_uInt8>(nSumB * fArea_1));
+
+                        for (nY = nY1; nY <= nY2; nY++)
+                        {
+                            Scanline pScanline = pWriteAcc->GetScanline(nY);
+                            for (nX = nX1; nX <= nX2; nX++)
+                                pWriteAcc->SetPixelOnData(pScanline, nX, aCol);
+                        }
+
+                        nX1 += mnTileWidth;
+                        nX2 += mnTileWidth;
+
+                        if (nX2 >= nWidth)
+                        {
+                            nX2 = nWidth - 1;
+                            fArea_1 = 1.0 / ((nX2 - nX1 + 1) * (nY2 - nY1 + 1));
+                        }
+                    } while (nX1 < nWidth);
+                }
+                else
+                {
+                    do
+                    {
+                        for (nY = nY1, nSumR = nSumG = nSumB = 0; nY <= nY2; nY++)
+                        {
+                            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+                            for (nX = nX1; nX <= nX2; nX++)
+                            {
+                                const BitmapColor& rCol = pReadAcc->GetPaletteColor(
+                                    pReadAcc->GetIndexFromData(pScanlineRead, nX));
+                                nSumR += rCol.GetRed();
+                                nSumG += rCol.GetGreen();
+                                nSumB += rCol.GetBlue();
+                            }
+                        }
+
+                        aCol.SetRed(static_cast<sal_uInt8>(nSumR * fArea_1));
+                        aCol.SetGreen(static_cast<sal_uInt8>(nSumG * fArea_1));
+                        aCol.SetBlue(static_cast<sal_uInt8>(nSumB * fArea_1));
+
+                        for (nY = nY1; nY <= nY2; nY++)
+                        {
+                            Scanline pScanline = pWriteAcc->GetScanline(nY);
+                            for (nX = nX1; nX <= nX2; nX++)
+                                pWriteAcc->SetPixelOnData(pScanline, nX, aCol);
+                        }
+
+                        nX1 += mnTileWidth;
+                        nX2 += mnTileWidth;
+
+                        if (nX2 >= nWidth)
+                        {
+                            nX2 = nWidth - 1;
+                            fArea_1 = 1.0 / ((nX2 - nX1 + 1) * (nY2 - nY1 + 1));
+                        }
+                    } while (nX1 < nWidth);
+                }
+
+                nY1 += mnTileHeight;
+                nY2 += mnTileHeight;
+
+                if (nY2 >= nHeight)
+                    nY2 = nHeight - 1;
+
+            } while (nY1 < nHeight);
+
+            bRet = true;
+        }
+
+        pReadAcc.reset();
+        pWriteAcc.reset();
+
+        if (pNewBmp)
+        {
+            if (bRet)
+            {
+                const MapMode aMap(aBitmap.GetPrefMapMode());
+                const Size aPrefSize(aBitmap.GetPrefSize());
+
+                aBitmap = *pNewBmp;
+
+                aBitmap.SetPrefMapMode(aMap);
+                aBitmap.SetPrefSize(aPrefSize);
+            }
+        }
+    }
+
+    if (bRet)
+        return BitmapEx(aBitmap);
+
+    return BitmapEx();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapPopArtFilter.cxx b/vcl/source/bitmap/BitmapPopArtFilter.cxx
new file mode 100644
index 0000000000..ee2cf716c9
--- /dev/null
+++ b/vcl/source/bitmap/BitmapPopArtFilter.cxx
@@ -0,0 +1,96 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <tools/solar.h>
+#include <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapPopArtFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+BitmapEx BitmapPopArtFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+    bool bRet = isPalettePixelFormat(aBitmap.getPixelFormat())
+                || aBitmap.Convert(BmpConversion::N8BitColors);
+
+    if (bRet)
+    {
+        bRet = false;
+
+        BitmapScopedWriteAccess pWriteAcc(aBitmap);
+
+        if (pWriteAcc)
+        {
+            const sal_Int32 nWidth = pWriteAcc->Width();
+            const sal_Int32 nHeight = pWriteAcc->Height();
+            const sal_uInt16 nEntryCount = 1 << pWriteAcc->GetBitCount();
+            sal_uInt16 n = 0;
+            std::vector<PopArtEntry> aPopArtTable(nEntryCount);
+
+            for (n = 0; n < nEntryCount; n++)
+            {
+                PopArtEntry& rEntry = aPopArtTable[n];
+                rEntry.mnIndex = n;
+                rEntry.mnCount = 0;
+            }
+
+            // get pixel count for each palette entry
+            for (sal_Int32 nY = 0; nY < nHeight; nY++)
+            {
+                Scanline pScanline = pWriteAcc->GetScanline(nY);
+                for (sal_Int32 nX = 0; nX < nWidth; nX++)
+                {
+                    aPopArtTable[pWriteAcc->GetIndexFromData(pScanline, nX)].mnCount++;
+                    assert(aPopArtTable[pWriteAcc->GetIndexFromData(pScanline, nX)].mnCount != 0);
+                }
+            }
+
+            // sort table
+            std::sort(aPopArtTable.begin(), aPopArtTable.end(),
+                      [](const PopArtEntry& lhs, const PopArtEntry& rhs) {
+                          return lhs.mnCount > rhs.mnCount;
+                      });
+
+            // get last used entry
+            sal_uInt16 nFirstEntry;
+            sal_uInt16 nLastEntry = 0;
+
+            for (n = 0; n < nEntryCount; n++)
+            {
+                if (aPopArtTable[n].mnCount)
+                    nLastEntry = n;
+            }
+
+            // rotate palette (one entry)
+            const BitmapColor aFirstCol(pWriteAcc->GetPaletteColor(aPopArtTable[0].mnIndex));
+
+            for (nFirstEntry = 0; nFirstEntry < nLastEntry; nFirstEntry++)
+            {
+                pWriteAcc->SetPaletteColor(
+                    aPopArtTable[nFirstEntry].mnIndex,
+                    pWriteAcc->GetPaletteColor(aPopArtTable[nFirstEntry + 1].mnIndex));
+            }
+
+            pWriteAcc->SetPaletteColor(aPopArtTable[nLastEntry].mnIndex, aFirstCol);
+
+            // cleanup
+            pWriteAcc.reset();
+            bRet = true;
+        }
+    }
+
+    if (bRet)
+        return BitmapEx(aBitmap);
+
+    return BitmapEx();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapReadAccess.cxx b/vcl/source/bitmap/BitmapReadAccess.cxx
new file mode 100644
index 0000000000..5dc3c944d9
--- /dev/null
+++ b/vcl/source/bitmap/BitmapReadAccess.cxx
@@ -0,0 +1,534 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <vcl/BitmapReadAccess.hxx>
+#include <vcl/BitmapTools.hxx>
+
+#include <salbmp.hxx>
+#include <svdata.hxx>
+#include <salinst.hxx>
+
+BitmapReadAccess::BitmapReadAccess(const AlphaMask& rBitmap, BitmapAccessMode nMode)
+    : BitmapReadAccess(rBitmap.GetBitmap(), nMode)
+{
+}
+
+BitmapReadAccess::BitmapReadAccess(const Bitmap& rBitmap, BitmapAccessMode nMode)
+    : BitmapInfoAccess(rBitmap, nMode)
+    , mFncGetPixel(nullptr)
+    , mFncSetPixel(nullptr)
+{
+    if (!mpBuffer)
+        return;
+
+    const std::shared_ptr<SalBitmap>& xImpBmp = rBitmap.ImplGetSalBitmap();
+    if (!xImpBmp)
+        return;
+
+    maColorMask = mpBuffer->maColorMask;
+
+    mFncGetPixel = GetPixelFunction(mpBuffer->mnFormat);
+    mFncSetPixel = SetPixelFunction(mpBuffer->mnFormat);
+
+    if (!mFncGetPixel || !mFncSetPixel)
+    {
+        xImpBmp->ReleaseBuffer(mpBuffer, mnAccessMode);
+        mpBuffer = nullptr;
+    }
+}
+
+BitmapReadAccess::~BitmapReadAccess() {}
+
+bool Bitmap32IsPreMultipled() { return ImplGetSVData()->mpDefInst->supportsBitmap32(); }
+
+FncGetPixel BitmapReadAccess::GetPixelFunction(ScanlineFormat nFormat)
+{
+    switch (RemoveScanline(nFormat))
+    {
+        case ScanlineFormat::N1BitMsbPal:
+            return GetPixelForN1BitMsbPal;
+        case ScanlineFormat::N8BitPal:
+            return GetPixelForN8BitPal;
+        case ScanlineFormat::N24BitTcBgr:
+            return GetPixelForN24BitTcBgr;
+        case ScanlineFormat::N24BitTcRgb:
+            return GetPixelForN24BitTcRgb;
+        case ScanlineFormat::N32BitTcAbgr:
+            if (Bitmap32IsPreMultipled())
+                return GetPixelForN32BitTcAbgr;
+            else
+                return GetPixelForN32BitTcXbgr;
+        case ScanlineFormat::N32BitTcArgb:
+            if (Bitmap32IsPreMultipled())
+                return GetPixelForN32BitTcArgb;
+            else
+                return GetPixelForN32BitTcXrgb;
+        case ScanlineFormat::N32BitTcBgra:
+            if (Bitmap32IsPreMultipled())
+                return GetPixelForN32BitTcBgra;
+            else
+                return GetPixelForN32BitTcBgrx;
+        case ScanlineFormat::N32BitTcRgba:
+            if (Bitmap32IsPreMultipled())
+                return GetPixelForN32BitTcRgba;
+            else
+                return GetPixelForN32BitTcRgbx;
+        case ScanlineFormat::N32BitTcMask:
+            return GetPixelForN32BitTcMask;
+
+        default:
+            return nullptr;
+    }
+}
+
+FncSetPixel BitmapReadAccess::SetPixelFunction(ScanlineFormat nFormat)
+{
+    switch (RemoveScanline(nFormat))
+    {
+        case ScanlineFormat::N1BitMsbPal:
+            return SetPixelForN1BitMsbPal;
+        case ScanlineFormat::N8BitPal:
+            return SetPixelForN8BitPal;
+        case ScanlineFormat::N24BitTcBgr:
+            return SetPixelForN24BitTcBgr;
+        case ScanlineFormat::N24BitTcRgb:
+            return SetPixelForN24BitTcRgb;
+        case ScanlineFormat::N32BitTcAbgr:
+            if (Bitmap32IsPreMultipled())
+                return SetPixelForN32BitTcAbgr;
+            else
+                return SetPixelForN32BitTcXbgr;
+        case ScanlineFormat::N32BitTcArgb:
+            if (Bitmap32IsPreMultipled())
+                return SetPixelForN32BitTcArgb;
+            else
+                return SetPixelForN32BitTcXrgb;
+        case ScanlineFormat::N32BitTcBgra:
+            if (Bitmap32IsPreMultipled())
+                return SetPixelForN32BitTcBgra;
+            else
+                return SetPixelForN32BitTcBgrx;
+        case ScanlineFormat::N32BitTcRgba:
+            if (Bitmap32IsPreMultipled())
+                return SetPixelForN32BitTcRgba;
+            else
+                return SetPixelForN32BitTcRgbx;
+        case ScanlineFormat::N32BitTcMask:
+            return SetPixelForN32BitTcMask;
+
+        default:
+            return nullptr;
+    }
+}
+
+BitmapColor BitmapReadAccess::GetInterpolatedColorWithFallback(double fY, double fX,
+                                                               const BitmapColor& rFallback) const
+{
+    // ask directly doubles >= 0.0 here to avoid rounded values of 0 at small negative
+    // double values, e.g. static_cast< sal_Int32 >(-0.25) is 0, not -1, but *has* to be outside (!)
+    if (mpBuffer && fX >= 0.0 && fY >= 0.0)
+    {
+        const sal_Int64 nX(static_cast<sal_Int64>(fX));
+        const sal_Int64 nY(static_cast<sal_Int64>(fY));
+
+        if (nX < mpBuffer->mnWidth && nY < mpBuffer->mnHeight)
+        {
+            // get base-return value from inside pixel
+            BitmapColor aRetval(GetColor(nY, nX));
+
+            // calculate deltas and indices for neighbour accesses
+            sal_Int16 nDeltaX((fX - (nX + 0.5)) * 255.0); // [-255 .. 255]
+            sal_Int16 nDeltaY((fY - (nY + 0.5)) * 255.0); // [-255 .. 255]
+            sal_Int16 nIndX(0);
+            sal_Int16 nIndY(0);
+
+            if (nDeltaX > 0)
+            {
+                nIndX = nX + 1;
+            }
+            else
+            {
+                nIndX = nX - 1;
+                nDeltaX = -nDeltaX;
+            }
+
+            if (nDeltaY > 0)
+            {
+                nIndY = nY + 1;
+            }
+            else
+            {
+                nIndY = nY - 1;
+                nDeltaY = -nDeltaY;
+            }
+
+            // get right/left neighbour
+            BitmapColor aXCol(rFallback);
+
+            if (nDeltaX && nIndX >= 0 && nIndX < mpBuffer->mnWidth)
+            {
+                aXCol = GetColor(nY, nIndX);
+            }
+
+            // get top/bottom neighbour
+            BitmapColor aYCol(rFallback);
+
+            if (nDeltaY && nIndY >= 0 && nIndY < mpBuffer->mnHeight)
+            {
+                aYCol = GetColor(nIndY, nX);
+            }
+
+            // get one of four edge neighbours
+            BitmapColor aXYCol(rFallback);
+
+            if (nDeltaX && nDeltaY && nIndX >= 0 && nIndY >= 0 && nIndX < mpBuffer->mnWidth
+                && nIndY < mpBuffer->mnHeight)
+            {
+                aXYCol = GetColor(nIndY, nIndX);
+            }
+
+            // merge return value with right/left neighbour
+            if (aXCol != aRetval)
+            {
+                aRetval.Merge(aXCol, 255 - nDeltaX);
+            }
+
+            // merge top/bottom neighbour with edge
+            if (aYCol != aXYCol)
+            {
+                aYCol.Merge(aXYCol, 255 - nDeltaX);
+            }
+
+            // merge return value with already merged top/bottom neighbour
+            if (aRetval != aYCol)
+            {
+                aRetval.Merge(aYCol, 255 - nDeltaY);
+            }
+
+            return aRetval;
+        }
+    }
+
+    return rFallback;
+}
+
+BitmapColor BitmapReadAccess::GetColorWithFallback(double fY, double fX,
+                                                   const BitmapColor& rFallback) const
+{
+    // ask directly doubles >= 0.0 here to avoid rounded values of 0 at small negative
+    // double values, e.g. static_cast< sal_Int32 >(-0.25) is 0, not -1, but *has* to be outside (!)
+    if (mpBuffer && fX >= 0.0 && fY >= 0.0)
+    {
+        const sal_Int32 nX(static_cast<sal_Int32>(fX));
+        const sal_Int32 nY(static_cast<sal_Int32>(fY));
+
+        if (nX < mpBuffer->mnWidth && nY < mpBuffer->mnHeight)
+        {
+            return GetColor(nY, nX);
+        }
+    }
+
+    return rFallback;
+}
+
+BitmapColor BitmapReadAccess::GetPixelForN1BitMsbPal(ConstScanline pScanline, tools::Long nX,
+                                                     const ColorMask&)
+{
+    return BitmapColor(pScanline[nX >> 3] & (1 << (7 - (nX & 7))) ? 1 : 0);
+}
+
+void BitmapReadAccess::SetPixelForN1BitMsbPal(const Scanline pScanline, tools::Long nX,
+                                              const BitmapColor& rBitmapColor, const ColorMask&)
+{
+    sal_uInt8& rByte = pScanline[nX >> 3];
+
+    if (rBitmapColor.GetIndex() & 1)
+        rByte |= 1 << (7 - (nX & 7));
+    else
+        rByte &= ~(1 << (7 - (nX & 7)));
+}
+
+BitmapColor BitmapReadAccess::GetPixelForN8BitPal(ConstScanline pScanline, tools::Long nX,
+                                                  const ColorMask&)
+{
+    return BitmapColor(pScanline[nX]);
+}
+
+void BitmapReadAccess::SetPixelForN8BitPal(Scanline pScanline, tools::Long nX,
+                                           const BitmapColor& rBitmapColor, const ColorMask&)
+{
+    pScanline[nX] = rBitmapColor.GetIndex();
+}
+
+BitmapColor BitmapReadAccess::GetPixelForN24BitTcBgr(ConstScanline pScanline, tools::Long nX,
+                                                     const ColorMask&)
+{
+    BitmapColor aBitmapColor;
+
+    pScanline = pScanline + nX * 3;
+    aBitmapColor.SetBlue(*pScanline++);
+    aBitmapColor.SetGreen(*pScanline++);
+    aBitmapColor.SetRed(*pScanline);
+
+    return aBitmapColor;
+}
+
+void BitmapReadAccess::SetPixelForN24BitTcBgr(Scanline pScanline, tools::Long nX,
+                                              const BitmapColor& rBitmapColor, const ColorMask&)
+{
+    pScanline = pScanline + nX * 3;
+    *pScanline++ = rBitmapColor.GetBlue();
+    *pScanline++ = rBitmapColor.GetGreen();
+    *pScanline = rBitmapColor.GetRed();
+}
+
+BitmapColor BitmapReadAccess::GetPixelForN24BitTcRgb(ConstScanline pScanline, tools::Long nX,
+                                                     const ColorMask&)
+{
+    BitmapColor aBitmapColor;
+
+    pScanline = pScanline + nX * 3;
+    aBitmapColor.SetRed(*pScanline++);
+    aBitmapColor.SetGreen(*pScanline++);
+    aBitmapColor.SetBlue(*pScanline);
+
+    return aBitmapColor;
+}
+
+void BitmapReadAccess::SetPixelForN24BitTcRgb(Scanline pScanline, tools::Long nX,
+                                              const BitmapColor& rBitmapColor, const ColorMask&)
+{
+    pScanline = pScanline + nX * 3;
+    *pScanline++ = rBitmapColor.GetRed();
+    *pScanline++ = rBitmapColor.GetGreen();
+    *pScanline = rBitmapColor.GetBlue();
+}
+
+BitmapColor BitmapReadAccess::GetPixelForN32BitTcAbgr(ConstScanline pScanline, tools::Long nX,
+                                                      const ColorMask&)
+{
+    pScanline = pScanline + nX * 4;
+
+    sal_uInt8 a = *pScanline++;
+    sal_uInt8 b = *pScanline++;
+    sal_uInt8 g = *pScanline++;
+    sal_uInt8 r = *pScanline;
+
+    return BitmapColor(ColorAlpha, vcl::bitmap::unpremultiply(r, a),
+                       vcl::bitmap::unpremultiply(g, a), vcl::bitmap::unpremultiply(b, a), a);
+}
+
+BitmapColor BitmapReadAccess::GetPixelForN32BitTcXbgr(ConstScanline pScanline, tools::Long nX,
+                                                      const ColorMask&)
+{
+    BitmapColor aBitmapColor;
+
+    pScanline = pScanline + (nX << 2) + 1;
+    aBitmapColor.SetBlue(*pScanline++);
+    aBitmapColor.SetGreen(*pScanline++);
+    aBitmapColor.SetRed(*pScanline);
+
+    return aBitmapColor;
+}
+
+void BitmapReadAccess::SetPixelForN32BitTcAbgr(Scanline pScanline, tools::Long nX,
+                                               const BitmapColor& rBitmapColor, const ColorMask&)
+{
+    pScanline = pScanline + nX * 4;
+
+    sal_uInt8 alpha = rBitmapColor.GetAlpha();
+    *pScanline++ = alpha;
+    *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetBlue(), alpha);
+    *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetGreen(), alpha);
+    *pScanline = vcl::bitmap::premultiply(rBitmapColor.GetRed(), alpha);
+}
+
+void BitmapReadAccess::SetPixelForN32BitTcXbgr(Scanline pScanline, tools::Long nX,
+                                               const BitmapColor& rBitmapColor, const ColorMask&)
+{
+    pScanline = pScanline + (nX << 2);
+    *pScanline++ = 0xFF;
+    *pScanline++ = rBitmapColor.GetBlue();
+    *pScanline++ = rBitmapColor.GetGreen();
+    *pScanline = rBitmapColor.GetRed();
+}
+
+BitmapColor BitmapReadAccess::GetPixelForN32BitTcArgb(ConstScanline pScanline, tools::Long nX,
+                                                      const ColorMask&)
+{
+    pScanline = pScanline + nX * 4;
+
+    sal_uInt8 a = *pScanline++;
+    sal_uInt8 r = *pScanline++;
+    sal_uInt8 g = *pScanline++;
+    sal_uInt8 b = *pScanline;
+
+    return BitmapColor(ColorAlpha, vcl::bitmap::unpremultiply(r, a),
+                       vcl::bitmap::unpremultiply(g, a), vcl::bitmap::unpremultiply(b, a), a);
+}
+
+BitmapColor BitmapReadAccess::GetPixelForN32BitTcXrgb(ConstScanline pScanline, tools::Long nX,
+                                                      const ColorMask&)
+{
+    BitmapColor aBitmapColor;
+
+    pScanline = pScanline + (nX << 2) + 1;
+    aBitmapColor.SetRed(*pScanline++);
+    aBitmapColor.SetGreen(*pScanline++);
+    aBitmapColor.SetBlue(*pScanline);
+
+    return aBitmapColor;
+}
+
+void BitmapReadAccess::SetPixelForN32BitTcArgb(Scanline pScanline, tools::Long nX,
+                                               const BitmapColor& rBitmapColor, const ColorMask&)
+{
+    pScanline = pScanline + nX * 4;
+
+    sal_uInt8 alpha = rBitmapColor.GetAlpha();
+    *pScanline++ = alpha;
+    *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetRed(), alpha);
+    *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetGreen(), alpha);
+    *pScanline = vcl::bitmap::premultiply(rBitmapColor.GetBlue(), alpha);
+}
+
+void BitmapReadAccess::SetPixelForN32BitTcXrgb(Scanline pScanline, tools::Long nX,
+                                               const BitmapColor& rBitmapColor, const ColorMask&)
+{
+    pScanline = pScanline + (nX << 2);
+    *pScanline++ = 0xFF;
+    *pScanline++ = rBitmapColor.GetRed();
+    *pScanline++ = rBitmapColor.GetGreen();
+    *pScanline = rBitmapColor.GetBlue();
+}
+
+BitmapColor BitmapReadAccess::GetPixelForN32BitTcBgra(ConstScanline pScanline, tools::Long nX,
+                                                      const ColorMask&)
+{
+    pScanline = pScanline + nX * 4;
+
+    sal_uInt8 b = *pScanline++;
+    sal_uInt8 g = *pScanline++;
+    sal_uInt8 r = *pScanline++;
+    sal_uInt8 a = *pScanline;
+
+    return BitmapColor(ColorAlpha, vcl::bitmap::unpremultiply(r, a),
+                       vcl::bitmap::unpremultiply(g, a), vcl::bitmap::unpremultiply(b, a), a);
+}
+
+BitmapColor BitmapReadAccess::GetPixelForN32BitTcBgrx(ConstScanline pScanline, tools::Long nX,
+                                                      const ColorMask&)
+{
+    BitmapColor aBitmapColor;
+
+    pScanline = pScanline + (nX << 2);
+    aBitmapColor.SetBlue(*pScanline++);
+    aBitmapColor.SetGreen(*pScanline++);
+    aBitmapColor.SetRed(*pScanline);
+
+    return aBitmapColor;
+}
+
+void BitmapReadAccess::SetPixelForN32BitTcBgra(Scanline pScanline, tools::Long nX,
+                                               const BitmapColor& rBitmapColor, const ColorMask&)
+{
+    pScanline = pScanline + nX * 4;
+
+    sal_uInt8 alpha = rBitmapColor.GetAlpha();
+    *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetBlue(), alpha);
+    *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetGreen(), alpha);
+    *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetRed(), alpha);
+    *pScanline = alpha;
+}
+
+void BitmapReadAccess::SetPixelForN32BitTcBgrx(Scanline pScanline, tools::Long nX,
+                                               const BitmapColor& rBitmapColor, const ColorMask&)
+{
+    pScanline = pScanline + (nX << 2);
+    *pScanline++ = rBitmapColor.GetBlue();
+    *pScanline++ = rBitmapColor.GetGreen();
+    *pScanline++ = rBitmapColor.GetRed();
+    *pScanline = 0xFF;
+}
+
+BitmapColor BitmapReadAccess::GetPixelForN32BitTcRgba(ConstScanline pScanline, tools::Long nX,
+                                                      const ColorMask&)
+{
+    pScanline = pScanline + nX * 4;
+
+    sal_uInt8 r = *pScanline++;
+    sal_uInt8 g = *pScanline++;
+    sal_uInt8 b = *pScanline++;
+    sal_uInt8 a = *pScanline;
+
+    return BitmapColor(ColorAlpha, vcl::bitmap::unpremultiply(r, a),
+                       vcl::bitmap::unpremultiply(g, a), vcl::bitmap::unpremultiply(b, a), a);
+}
+
+BitmapColor BitmapReadAccess::GetPixelForN32BitTcRgbx(ConstScanline pScanline, tools::Long nX,
+                                                      const ColorMask&)
+{
+    BitmapColor aBitmapColor;
+
+    pScanline = pScanline + (nX << 2);
+    aBitmapColor.SetRed(*pScanline++);
+    aBitmapColor.SetGreen(*pScanline++);
+    aBitmapColor.SetBlue(*pScanline);
+
+    return aBitmapColor;
+}
+
+void BitmapReadAccess::SetPixelForN32BitTcRgba(Scanline pScanline, tools::Long nX,
+                                               const BitmapColor& rBitmapColor, const ColorMask&)
+{
+    pScanline = pScanline + nX * 4;
+
+    sal_uInt8 alpha = rBitmapColor.GetAlpha();
+    *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetRed(), alpha);
+    *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetGreen(), alpha);
+    *pScanline++ = vcl::bitmap::premultiply(rBitmapColor.GetBlue(), alpha);
+    *pScanline = alpha;
+}
+
+void BitmapReadAccess::SetPixelForN32BitTcRgbx(Scanline pScanline, tools::Long nX,
+                                               const BitmapColor& rBitmapColor, const ColorMask&)
+{
+    pScanline = pScanline + (nX << 2);
+    *pScanline++ = rBitmapColor.GetRed();
+    *pScanline++ = rBitmapColor.GetGreen();
+    *pScanline++ = rBitmapColor.GetBlue();
+    *pScanline = 0xFF;
+}
+
+BitmapColor BitmapReadAccess::GetPixelForN32BitTcMask(ConstScanline pScanline, tools::Long nX,
+                                                      const ColorMask& rMask)
+{
+    BitmapColor aColor;
+    rMask.GetColorFor32Bit(aColor, pScanline + (nX << 2));
+    return aColor;
+}
+
+void BitmapReadAccess::SetPixelForN32BitTcMask(Scanline pScanline, tools::Long nX,
+                                               const BitmapColor& rBitmapColor,
+                                               const ColorMask& rMask)
+{
+    rMask.SetColorFor32Bit(rBitmapColor, pScanline + (nX << 2));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapScaleConvolutionFilter.cxx b/vcl/source/bitmap/BitmapScaleConvolutionFilter.cxx
new file mode 100644
index 0000000000..27df45f7ba
--- /dev/null
+++ b/vcl/source/bitmap/BitmapScaleConvolutionFilter.cxx
@@ -0,0 +1,381 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <osl/diagnose.h>
+#include <tools/helpers.hxx>
+
+#include <vcl/BitmapWriteAccess.hxx>
+#include <bitmap/BitmapScaleConvolutionFilter.hxx>
+
+#include <algorithm>
+#include <memory>
+
+namespace vcl
+{
+
+namespace
+{
+
+void ImplCalculateContributions(
+    const sal_Int32 aSourceSize,
+    const sal_Int32 aDestinationSize,
+    sal_Int32& aNumberOfContributions,
+    std::vector<sal_Int16>& rWeights,
+    std::vector<sal_Int32>& rPixels,
+    std::vector<sal_Int32>& rCounts,
+    const Kernel& aKernel)
+{
+    const double fSamplingRadius(aKernel.GetWidth());
+    const double fScale(aDestinationSize / static_cast< double >(aSourceSize));
+    const double fScaledRadius((fScale < 1.0) ? fSamplingRadius / fScale : fSamplingRadius);
+    const double fFilterFactor(std::min(fScale, 1.0));
+
+    aNumberOfContributions = (sal_Int32(fabs(ceil(fScaledRadius))) * 2) + 1;
+    const sal_Int32 nAllocSize(aDestinationSize * aNumberOfContributions);
+    rWeights.resize(nAllocSize);
+    rPixels.resize(nAllocSize);
+    rCounts.resize(aDestinationSize);
+
+    for(sal_Int32 i(0); i < aDestinationSize; i++)
+    {
+        const sal_Int32 aIndex(i * aNumberOfContributions);
+        const double aCenter(i / fScale);
+        const sal_Int32 aLeft(static_cast< sal_Int32 >(floor(aCenter - fScaledRadius)));
+        const sal_Int32 aRight(static_cast< sal_Int32 >(ceil(aCenter + fScaledRadius)));
+        sal_Int32 aCurrentCount(0);
+
+        for(sal_Int32 j(aLeft); j <= aRight; j++)
+        {
+            const double aWeight(aKernel.Calculate(fFilterFactor * (aCenter - static_cast< double>(j))));
+
+            // Reduce calculations with ignoring weights of 0.0
+            if(fabs(aWeight) < 0.0001)
+            {
+                continue;
+            }
+
+            // Handling on edges
+            const sal_Int32 aPixelIndex(std::clamp(j, sal_Int32(0), aSourceSize - 1));
+            const sal_Int32 nIndex(aIndex + aCurrentCount);
+
+            // scale the weight by 255 since we're converting from float to int
+            rWeights[nIndex] = aWeight * 255;
+            rPixels[nIndex] = aPixelIndex;
+
+            aCurrentCount++;
+        }
+
+        rCounts[i] = aCurrentCount;
+    }
+}
+
+bool ImplScaleConvolutionHor(Bitmap& rSource, Bitmap& rTarget, const double& rScaleX, const Kernel& aKernel)
+{
+    // Do horizontal filtering
+    OSL_ENSURE(rScaleX > 0.0, "Error in scaling: Mirror given in non-mirror-capable method (!)");
+    const sal_Int32 nWidth(rSource.GetSizePixel().Width());
+    const sal_Int32 nNewWidth(FRound(nWidth * rScaleX));
+
+    if(nWidth == nNewWidth)
+    {
+        return true;
+    }
+
+    BitmapScopedReadAccess pReadAcc(rSource);
+
+    if(pReadAcc)
+    {
+        std::vector<sal_Int16> aWeights;
+        std::vector<sal_Int32> aPixels;
+        std::vector<sal_Int32> aCounts;
+        sal_Int32 aNumberOfContributions(0);
+
+        const sal_Int32 nHeight(rSource.GetSizePixel().Height());
+        ImplCalculateContributions(nWidth, nNewWidth, aNumberOfContributions, aWeights, aPixels, aCounts, aKernel);
+        rTarget = Bitmap(Size(nNewWidth, nHeight), vcl::PixelFormat::N24_BPP);
+        BitmapScopedWriteAccess pWriteAcc(rTarget);
+        bool bResult(pWriteAcc);
+
+        if(bResult)
+        {
+            for(sal_Int32 y(0); y < nHeight; y++)
+            {
+                Scanline pScanline = pWriteAcc->GetScanline( y );
+                Scanline pScanlineRead = pReadAcc->GetScanline( y );
+                for(sal_Int32 x(0); x < nNewWidth; x++)
+                {
+                    const sal_Int32 aBaseIndex(x * aNumberOfContributions);
+                    sal_Int32 aSum(0);
+                    sal_Int32 aValueRed(0);
+                    sal_Int32 aValueGreen(0);
+                    sal_Int32 aValueBlue(0);
+
+                    for(sal_Int32 j(0); j < aCounts[x]; j++)
+                    {
+                        const sal_Int32 aIndex(aBaseIndex + j);
+                        const sal_Int16 aWeight(aWeights[aIndex]);
+                        BitmapColor aColor;
+
+                        aSum += aWeight;
+
+                        if(pReadAcc->HasPalette())
+                        {
+                            aColor = pReadAcc->GetPaletteColor(pReadAcc->GetIndexFromData(pScanlineRead, aPixels[aIndex]));
+                        }
+                        else
+                        {
+                            aColor = pReadAcc->GetPixelFromData(pScanlineRead, aPixels[aIndex]);
+                        }
+
+                        aValueRed += aWeight * aColor.GetRed();
+                        aValueGreen += aWeight * aColor.GetGreen();
+                        aValueBlue += aWeight * aColor.GetBlue();
+                    }
+
+                    assert(aSum != 0);
+
+                    const BitmapColor aResultColor(
+                        static_cast< sal_uInt8 >(std::clamp< sal_Int32 >(aValueRed / aSum, 0, 255)),
+                        static_cast< sal_uInt8 >(std::clamp< sal_Int32 >(aValueGreen / aSum, 0, 255)),
+                        static_cast< sal_uInt8 >(std::clamp< sal_Int32 >(aValueBlue / aSum, 0, 255)));
+
+                    pWriteAcc->SetPixelOnData(pScanline, x, aResultColor);
+                }
+            }
+
+            pWriteAcc.reset();
+        }
+
+        aWeights.clear();
+        aCounts.clear();
+        aPixels.clear();
+
+        if(bResult)
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool ImplScaleConvolutionVer(Bitmap& rSource, Bitmap& rTarget, const double& rScaleY, const Kernel& aKernel)
+{
+    // Do vertical filtering
+    OSL_ENSURE(rScaleY > 0.0, "Error in scaling: Mirror given in non-mirror-capable method (!)");
+    const sal_Int32 nHeight(rSource.GetSizePixel().Height());
+    const sal_Int32 nNewHeight(FRound(nHeight * rScaleY));
+
+    if(nHeight == nNewHeight)
+    {
+        return true;
+    }
+
+    BitmapScopedReadAccess pReadAcc(rSource);
+    if(!pReadAcc)
+        return false;
+
+    std::vector<sal_Int16> aWeights;
+    std::vector<sal_Int32> aPixels;
+    std::vector<sal_Int32> aCounts;
+    sal_Int32 aNumberOfContributions(0);
+
+    const sal_Int32 nWidth(rSource.GetSizePixel().Width());
+    ImplCalculateContributions(nHeight, nNewHeight, aNumberOfContributions, aWeights, aPixels, aCounts, aKernel);
+    rTarget = Bitmap(Size(nWidth, nNewHeight), vcl::PixelFormat::N24_BPP);
+    BitmapScopedWriteAccess pWriteAcc(rTarget);
+    if(!pWriteAcc)
+        return false;
+
+    std::vector<BitmapColor> aScanline(nHeight);
+    for(sal_Int32 x(0); x < nWidth; x++)
+    {
+        for(sal_Int32 y(0); y < nHeight; y++)
+                if(pReadAcc->HasPalette())
+                    aScanline[y] = pReadAcc->GetPaletteColor(pReadAcc->GetPixelIndex(y, x));
+                else
+                    aScanline[y] = pReadAcc->GetPixel(y, x);
+        for(sal_Int32 y(0); y < nNewHeight; y++)
+        {
+            const sal_Int32 aBaseIndex(y * aNumberOfContributions);
+            sal_Int32 aSum(0);
+            sal_Int32 aValueRed(0);
+            sal_Int32 aValueGreen(0);
+            sal_Int32 aValueBlue(0);
+
+            for(sal_Int32 j(0); j < aCounts[y]; j++)
+            {
+                const sal_Int32 aIndex(aBaseIndex + j);
+                const sal_Int16 aWeight(aWeights[aIndex]);
+                aSum += aWeight;
+                const BitmapColor & aColor = aScanline[aPixels[aIndex]];
+                aValueRed += aWeight * aColor.GetRed();
+                aValueGreen += aWeight * aColor.GetGreen();
+                aValueBlue += aWeight * aColor.GetBlue();
+            }
+
+            assert(aSum != 0);
+
+            const BitmapColor aResultColor(
+                static_cast< sal_uInt8 >(std::clamp< sal_Int32 >(aValueRed / aSum, 0, 255)),
+                static_cast< sal_uInt8 >(std::clamp< sal_Int32 >(aValueGreen / aSum, 0, 255)),
+                static_cast< sal_uInt8 >(std::clamp< sal_Int32 >(aValueBlue / aSum, 0, 255)));
+
+            if(pWriteAcc->HasPalette())
+            {
+                pWriteAcc->SetPixelIndex(y, x, static_cast< sal_uInt8 >(pWriteAcc->GetBestPaletteIndex(aResultColor)));
+            }
+            else
+            {
+                pWriteAcc->SetPixel(y, x, aResultColor);
+            }
+        }
+    }
+
+    aWeights.clear();
+    aCounts.clear();
+    aPixels.clear();
+
+    return true;
+}
+
+bool ImplScaleConvolution(Bitmap& rBitmap, const double& rScaleX, const double& rScaleY, const Kernel& aKernel)
+{
+    const bool bMirrorHor(rScaleX < 0.0);
+    const bool bMirrorVer(rScaleY < 0.0);
+    const double fScaleX(bMirrorHor ? -rScaleX : rScaleX);
+    const double fScaleY(bMirrorVer ? -rScaleY : rScaleY);
+    const sal_Int32 nWidth(rBitmap.GetSizePixel().Width());
+    const sal_Int32 nHeight(rBitmap.GetSizePixel().Height());
+    const sal_Int32 nNewWidth(FRound(nWidth * fScaleX));
+    const sal_Int32 nNewHeight(FRound(nHeight * fScaleY));
+    const bool bScaleHor(nWidth != nNewWidth);
+    const bool bScaleVer(nHeight != nNewHeight);
+    const bool bMirror(bMirrorHor || bMirrorVer);
+
+    if (!bMirror && !bScaleHor && !bScaleVer)
+    {
+        return true;
+    }
+
+    bool bResult(true);
+    BmpMirrorFlags nMirrorFlags(BmpMirrorFlags::NONE);
+    bool bMirrorAfter(false);
+
+    if (bMirror)
+    {
+        if(bMirrorHor)
+        {
+            nMirrorFlags |= BmpMirrorFlags::Horizontal;
+        }
+
+        if(bMirrorVer)
+        {
+            nMirrorFlags |= BmpMirrorFlags::Vertical;
+        }
+
+        const sal_Int32 nStartSize(nWidth * nHeight);
+        const sal_Int32 nEndSize(nNewWidth * nNewHeight);
+
+        bMirrorAfter = nStartSize > nEndSize;
+
+        if(!bMirrorAfter)
+        {
+            bResult = rBitmap.Mirror(nMirrorFlags);
+        }
+    }
+
+    Bitmap aResult;
+
+    if (bResult)
+    {
+        const sal_Int32 nInBetweenSizeHorFirst(nHeight * nNewWidth);
+        const sal_Int32 nInBetweenSizeVerFirst(nNewHeight * nWidth);
+        Bitmap aSource(rBitmap);
+
+        if(nInBetweenSizeHorFirst < nInBetweenSizeVerFirst)
+        {
+            if(bScaleHor)
+            {
+                bResult = ImplScaleConvolutionHor(aSource, aResult, fScaleX, aKernel);
+            }
+
+            if(bResult && bScaleVer)
+            {
+                if(bScaleHor)
+                {
+                    // copy partial result, independent of color depth
+                    aSource = aResult;
+                }
+
+                bResult = ImplScaleConvolutionVer(aSource, aResult, fScaleY, aKernel);
+            }
+        }
+        else
+        {
+            if(bScaleVer)
+            {
+                bResult = ImplScaleConvolutionVer(aSource, aResult, fScaleY, aKernel);
+            }
+
+            if(bResult && bScaleHor)
+            {
+                if(bScaleVer)
+                {
+                    // copy partial result, independent of color depth
+                    aSource = aResult;
+                }
+
+                bResult = ImplScaleConvolutionHor(aSource, aResult, fScaleX, aKernel);
+            }
+        }
+    }
+
+    if(bResult && bMirrorAfter)
+    {
+        bResult = aResult.Mirror(nMirrorFlags);
+    }
+
+    if(bResult)
+    {
+        rBitmap.AdaptBitCount(aResult);
+        rBitmap = aResult;
+    }
+
+    return bResult;
+}
+
+} // end anonymous namespace
+
+BitmapEx BitmapScaleConvolutionFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    bool bRetval = false;
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+    bRetval = ImplScaleConvolution(aBitmap, mrScaleX, mrScaleY, *mxKernel);
+
+    if (bRetval)
+        return BitmapEx(aBitmap);
+
+    return BitmapEx();
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapScaleSuperFilter.cxx b/vcl/source/bitmap/BitmapScaleSuperFilter.cxx
new file mode 100644
index 0000000000..3c844c690e
--- /dev/null
+++ b/vcl/source/bitmap/BitmapScaleSuperFilter.cxx
@@ -0,0 +1,1046 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <comphelper/profilezone.hxx>
+#include <comphelper/threadpool.hxx>
+#include <tools/helpers.hxx>
+
+#include <vcl/BitmapWriteAccess.hxx>
+#include <bitmap/BitmapScaleSuperFilter.hxx>
+
+#include <algorithm>
+#include <memory>
+#include <svdata.hxx>
+#include <sal/log.hxx>
+
+/*
+A scaling algorithm that uses bilinear if not downscaling too much,
+and averaging otherwise (bilinear would produce poor results for big downscaling).
+
+By default the combination of two filters is used: bilinear and averaging algorithm. 
+Bilinear filtering is used for bitmap enlarging and shrinking till factor 0.6. Below
+this bilinear gives bad results because of limited sampling. For such cases averaging 
+is used which is a simple algorithm for shrinking. In averaging the algorithm 
+calculates the average of samples which result is the new pixel.
+*/
+
+namespace {
+
+constexpr int MAP_PRECISION = 7;
+
+typedef sal_Int32 BilinearWeightType;
+
+constexpr BilinearWeightType lclMaxWeight()
+{
+    return BilinearWeightType(1) << MAP_PRECISION;
+}
+
+constexpr sal_uInt8 MAP(sal_uInt8 cVal0, sal_uInt8 cVal1, BilinearWeightType nFrac)
+{
+    return sal_uInt8(((BilinearWeightType(cVal0) << MAP_PRECISION) + nFrac * (BilinearWeightType(cVal1) - BilinearWeightType(cVal0))) >> MAP_PRECISION);
+}
+
+struct ScaleContext
+{
+    BitmapReadAccess*  mpSrc;
+    BitmapWriteAccess* mpDest;
+    sal_Int32 mnDestW;
+    bool mbHMirr;
+    bool mbVMirr;
+    std::vector<sal_Int32> maMapIX;
+    std::vector<sal_Int32> maMapIY;
+    std::vector<BilinearWeightType> maMapFX;
+    std::vector<BilinearWeightType> maMapFY;
+
+    ScaleContext( BitmapReadAccess *pSrc,
+                  BitmapWriteAccess *pDest,
+                  sal_Int32 nSrcW, sal_Int32 nDestW,
+                  sal_Int32 nSrcH, sal_Int32 nDestH,
+                  bool bHMirr, bool bVMirr)
+        : mpSrc(pSrc)
+        , mpDest(pDest)
+        , mnDestW(nDestW)
+        , mbHMirr(bHMirr)
+        , mbVMirr(bVMirr)
+        , maMapIX(nDestW)
+        , maMapIY(nDestH)
+        , maMapFX(nDestW)
+        , maMapFY(nDestH)
+    {
+        generateMap(nSrcW, nDestW, bHMirr, maMapIX, maMapFX);
+        generateMap(nSrcH, nDestH, bVMirr, maMapIY, maMapFY);
+    }
+
+    static void generateMap(sal_Int32 nSourceLength, sal_Int32 nDestinationLength, bool bMirrored,
+        std::vector<sal_Int32> & rMapIX, std::vector<BilinearWeightType> & rMapFX)
+    {
+        const double fRevScale = (nDestinationLength > 1) ? double(nSourceLength - 1) / (nDestinationLength - 1) : 0.0;
+
+        sal_Int32 nTemp = nSourceLength - 2;
+        sal_Int32 nTempX = nSourceLength - 1;
+
+        for (sal_Int32 i = 0; i < nDestinationLength; i++)
+        {
+            double fTemp = i * fRevScale;
+            if (bMirrored)
+                fTemp = nTempX - fTemp;
+            rMapIX[i] = std::clamp(sal_Int32(fTemp), sal_Int32(0), nTemp);
+            rMapFX[i] = BilinearWeightType((fTemp - rMapIX[i]) * (BilinearWeightType(1) << MAP_PRECISION));
+        }
+    }
+};
+
+constexpr sal_Int32 constScaleThreadStrip = 32;
+
+typedef void (*ScaleRangeFn)(const ScaleContext & rContext, sal_Int32 nStartY, sal_Int32 nEndY);
+
+template <size_t nSize> struct ScaleFunc
+{
+    // for scale down
+
+    static inline void generateSumRows(Scanline& pTmpX, std::array<int, nSize>& sumRows)
+    {
+        for (int& n : sumRows)
+            n += (*pTmpX++) << MAP_PRECISION;
+    }
+
+    static inline void generateSumRows(BilinearWeightType const nWeightX, Scanline& pTmpX,
+                                       std::array<int, nSize>& sumRows)
+    {
+        for (int& n : sumRows)
+            n += (nWeightX * (*pTmpX++));
+    }
+
+    static inline void generateSumRows(BilinearWeightType const nTotalWeightX,
+                                       std::array<int, nSize>& sumRows)
+    {
+        for (int& n : sumRows)
+            n /= nTotalWeightX;
+    }
+
+    static inline void generateSumNumbers(BilinearWeightType const nWeightY,
+                                          std::array<int, nSize>& sumRows,
+                                          std::array<int, nSize>& sumNumbers)
+    {
+        std::transform(sumRows.begin(), sumRows.end(), sumNumbers.begin(), sumNumbers.begin(),
+                       [nWeightY](int n1, int n2) { return nWeightY * n1 + n2; });
+    }
+
+    static inline void generateSumNumbers(BilinearWeightType const nTotalWeightY,
+                                          std::array<int, nSize>& sumNumbers)
+    {
+        for (int& n : sumNumbers)
+            n /= nTotalWeightY;
+    }
+
+    static inline void calculateDestination(Scanline& pScanDest, std::array<int, nSize>& sumNumbers)
+    {
+        pScanDest = std::copy(sumNumbers.begin(), sumNumbers.end(), pScanDest);
+    }
+
+    // for scale up
+
+    static inline void generateComponent(Scanline pColorPtr0, Scanline pColorPtr1,
+                                         BilinearWeightType const nTempFX,
+                                         std::array<sal_uInt8, nSize>& nComponents)
+    {
+        for (sal_uInt8& rComponent : nComponents)
+            rComponent = MAP(*pColorPtr0++, *pColorPtr1++, nTempFX);
+    }
+
+    static inline void calculateDestination(Scanline& pScanDest, BilinearWeightType const nTempFY,
+                                            const std::array<sal_uInt8, nSize>& nComponents1,
+                                            const std::array<sal_uInt8, nSize>& nComponents2)
+    {
+        pScanDest = std::transform(
+            nComponents1.begin(), nComponents1.end(), nComponents2.begin(), pScanDest,
+            [nTempFY](sal_uInt8 c1, sal_uInt8 c2) { return MAP(c1, c2, nTempFY); });
+    }
+};
+
+template <int nColorBits>
+void scaleDown (const ScaleContext &rCtx, sal_Int32 nStartY, sal_Int32 nEndY)
+{
+    comphelper::ProfileZone pz("BitmapScaleSuperFilter::scaleDown");
+    constexpr int nColorComponents = nColorBits / 8;
+    static_assert(nColorComponents * 8 == nColorBits, "nColorBits must be divisible by 8");
+    using ScaleFunction = ScaleFunc<nColorComponents>;
+    const sal_Int32 nStartX = 0;
+    const sal_Int32 nEndX = rCtx.mnDestW - 1;
+
+    for (sal_Int32 nY = nStartY; nY <= nEndY; nY++)
+    {
+        sal_Int32 nTop = rCtx.mbVMirr ? (nY + 1) : nY;
+        sal_Int32 nBottom = rCtx.mbVMirr ? nY : (nY + 1);
+
+        sal_Int32 nLineStart;
+        sal_Int32 nLineRange;
+        if (nY == nEndY)
+        {
+            nLineStart = rCtx.maMapIY[nY];
+            nLineRange = 0;
+        }
+        else
+        {
+            nLineStart = rCtx.maMapIY[nTop];
+            nLineRange = (rCtx.maMapIY[nBottom] == rCtx.maMapIY[nTop]) ?
+                            1 : (rCtx.maMapIY[nBottom] - rCtx.maMapIY[nTop]);
+        }
+
+        Scanline pScanDest = rCtx.mpDest->GetScanline(nY);
+        for (sal_Int32 nX = nStartX; nX <= nEndX; nX++)
+        {
+            sal_Int32 nLeft = rCtx.mbHMirr ? (nX + 1) : nX;
+            sal_Int32 nRight = rCtx.mbHMirr ? nX : (nX + 1);
+
+            sal_Int32 nRowStart;
+            sal_Int32 nRowRange;
+            if (nX == nEndX)
+            {
+                nRowStart = rCtx.maMapIX[nX];
+                nRowRange = 0;
+            }
+            else
+            {
+                nRowStart = rCtx.maMapIX[nLeft];
+                nRowRange = (rCtx.maMapIX[nRight] == rCtx.maMapIX[nLeft]) ?
+                                1 : (rCtx.maMapIX[nRight] - rCtx.maMapIX[nLeft]);
+            }
+
+            std::array<int, nColorComponents> sumNumbers{}; // zero-initialize
+            BilinearWeightType nTotalWeightY = 0;
+
+            for (sal_Int32 i = 0; i<= nLineRange; i++)
+            {
+                Scanline pTmpY = rCtx.mpSrc->GetScanline(nLineStart + i);
+                Scanline pTmpX = pTmpY + nColorComponents * nRowStart;
+
+                std::array<int, nColorComponents> sumRows{}; // zero-initialize
+                BilinearWeightType nTotalWeightX = 0;
+
+                for (sal_Int32 j = 0; j <= nRowRange; j++)
+                {
+                    if (nX == nEndX)
+                    {
+                        ScaleFunction::generateSumRows(pTmpX, sumRows);
+                        nTotalWeightX += lclMaxWeight();
+                    }
+                    else if(j == 0)
+                    {
+                        BilinearWeightType nWeightX = lclMaxWeight() - rCtx.maMapFX[nLeft];
+                        ScaleFunction::generateSumRows(nWeightX, pTmpX, sumRows);
+                        nTotalWeightX += nWeightX;
+                    }
+                    else if ( nRowRange == j )
+                    {
+                        BilinearWeightType nWeightX = rCtx.maMapFX[ nRight ] ;
+                        ScaleFunction::generateSumRows(nWeightX, pTmpX, sumRows);
+                        nTotalWeightX += nWeightX;
+                    }
+                    else
+                    {
+                       ScaleFunction::generateSumRows(pTmpX, sumRows);
+                       nTotalWeightX += lclMaxWeight();
+                    }
+                }
+
+                BilinearWeightType nWeightY = lclMaxWeight();
+                if (nY == nEndY)
+                    nWeightY = lclMaxWeight();
+                else if (i == 0)
+                    nWeightY = lclMaxWeight() - rCtx.maMapFY[nTop];
+                else if (nLineRange == 1)
+                    nWeightY = rCtx.maMapFY[nTop];
+                else if (nLineRange == i)
+                    nWeightY = rCtx.maMapFY[nBottom];
+
+                if (nTotalWeightX)
+                {
+                  ScaleFunction::generateSumRows(nTotalWeightX, sumRows);
+                }
+                ScaleFunction::generateSumNumbers(nWeightY, sumRows, sumNumbers);
+                nTotalWeightY += nWeightY;
+
+            }
+
+            if (nTotalWeightY)
+            {
+                ScaleFunction::generateSumNumbers(nTotalWeightY, sumNumbers);
+            }
+
+            // Write the calculated color components to the destination
+            ScaleFunction::calculateDestination(pScanDest, sumNumbers);
+        }
+    }
+}
+
+template <int nColorBits>
+void scaleUp(const ScaleContext &rCtx, sal_Int32 nStartY, sal_Int32 nEndY)
+{
+    comphelper::ProfileZone pz("BitmapScaleSuperFilter::scaleUp");
+    constexpr int nColorComponents = nColorBits / 8;
+    static_assert(nColorComponents * 8 == nColorBits, "nColorBits must be divisible by 8");
+    using ScaleFunction = ScaleFunc<nColorComponents>;
+    const sal_Int32 nStartX = 0;
+    const sal_Int32 nEndX = rCtx.mnDestW - 1;
+
+    for (sal_Int32 nY = nStartY; nY <= nEndY; nY++)
+    {
+        sal_Int32 nTempY = rCtx.maMapIY[nY];
+        BilinearWeightType nTempFY = rCtx.maMapFY[nY];
+
+        Scanline pLine0 = rCtx.mpSrc->GetScanline(nTempY+0);
+        Scanline pLine1 = rCtx.mpSrc->GetScanline(nTempY+1);
+        Scanline pScanDest = rCtx.mpDest->GetScanline(nY);
+
+        std::array<sal_uInt8, nColorComponents> nComponents1; // no need to initialize since it's
+        std::array<sal_uInt8, nColorComponents> nComponents2; // initialized in generateComponent
+
+        Scanline pColorPtr0;
+        Scanline pColorPtr1;
+
+        for (sal_Int32 nX = nStartX; nX <= nEndX; nX++)
+        {
+            sal_Int32 nTempX = rCtx.maMapIX[nX];
+            BilinearWeightType nTempFX = rCtx.maMapFX[nX];
+
+            pColorPtr0 = pLine0 + nTempX * nColorComponents;
+            pColorPtr1 = pColorPtr0 + nColorComponents;
+
+            ScaleFunction::generateComponent(pColorPtr0, pColorPtr1, nTempFX, nComponents1);
+
+            pColorPtr0 = pLine1 + nTempX * nColorComponents;
+            pColorPtr1 = pColorPtr0 + nColorComponents;
+
+            ScaleFunction::generateComponent(pColorPtr0, pColorPtr1, nTempFX, nComponents2);
+            ScaleFunction::calculateDestination(pScanDest, nTempFY, nComponents1, nComponents2);
+        }
+    }
+}
+
+class ScaleTask : public comphelper::ThreadTask
+{
+    ScaleRangeFn mpScaleRangeFunction;
+    const ScaleContext& mrContext;
+    sal_Int32 mnStartY;
+    sal_Int32 mnEndY;
+
+public:
+    explicit ScaleTask(const std::shared_ptr<comphelper::ThreadTaskTag>& pTag,
+                       ScaleRangeFn pScaleRangeFunction,
+                       const ScaleContext& rContext,
+                       sal_Int32 nStartY, sal_Int32 nEndY)
+        : comphelper::ThreadTask(pTag)
+        , mpScaleRangeFunction(pScaleRangeFunction)
+        , mrContext(rContext)
+        , mnStartY(nStartY)
+        , mnEndY(nEndY)
+    {}
+
+    virtual void doWork() override
+    {
+        mpScaleRangeFunction(mrContext, mnStartY, mnEndY);
+    }
+};
+
+void scaleUpPalette8bit(const ScaleContext &rCtx, sal_Int32 nStartY, sal_Int32 nEndY)
+{
+    const sal_Int32 nStartX = 0, nEndX = rCtx.mnDestW - 1;
+
+    for( sal_Int32 nY = nStartY; nY <= nEndY; nY++ )
+    {
+        sal_Int32 nTempY = rCtx.maMapIY[ nY ];
+        BilinearWeightType nTempFY = rCtx.maMapFY[ nY ];
+        Scanline pLine0 = rCtx.mpSrc->GetScanline( nTempY );
+        Scanline pLine1 = rCtx.mpSrc->GetScanline( ++nTempY );
+        Scanline pScanDest = rCtx.mpDest->GetScanline( nY );
+
+        for(sal_Int32 nX = nStartX, nXDst = 0; nX <= nEndX; nX++ )
+        {
+            sal_Int32 nTempX = rCtx.maMapIX[ nX ];
+            BilinearWeightType nTempFX = rCtx.maMapFX[ nX ];
+
+            const BitmapColor& rCol0 = rCtx.mpSrc->GetPaletteColor( pLine0[ nTempX ] );
+            const BitmapColor& rCol2 = rCtx.mpSrc->GetPaletteColor( pLine1[ nTempX ] );
+            const BitmapColor& rCol1 = rCtx.mpSrc->GetPaletteColor( pLine0[ ++nTempX ] );
+            const BitmapColor& rCol3 = rCtx.mpSrc->GetPaletteColor( pLine1[ nTempX ] );
+
+            sal_uInt8 cR0 = MAP( rCol0.GetRed(), rCol1.GetRed(), nTempFX );
+            sal_uInt8 cG0 = MAP( rCol0.GetGreen(), rCol1.GetGreen(), nTempFX );
+            sal_uInt8 cB0 = MAP( rCol0.GetBlue(), rCol1.GetBlue(), nTempFX );
+
+            sal_uInt8 cR1 = MAP( rCol2.GetRed(), rCol3.GetRed(), nTempFX );
+            sal_uInt8 cG1 = MAP( rCol2.GetGreen(), rCol3.GetGreen(), nTempFX );
+            sal_uInt8 cB1 = MAP( rCol2.GetBlue(), rCol3.GetBlue(), nTempFX );
+
+            BitmapColor aColRes( MAP( cR0, cR1, nTempFY ),
+                    MAP( cG0, cG1, nTempFY ),
+                    MAP( cB0, cB1, nTempFY ) );
+            rCtx.mpDest->SetPixelOnData( pScanDest, nXDst++, aColRes );
+        }
+    }
+}
+
+void scaleUpPaletteGeneral(const ScaleContext &rCtx, sal_Int32 nStartY, sal_Int32 nEndY)
+{
+    const sal_Int32 nStartX = 0, nEndX = rCtx.mnDestW - 1;
+
+    for( sal_Int32 nY = nStartY; nY <= nEndY; nY++ )
+    {
+        sal_Int32 nTempY = rCtx.maMapIY[ nY ];
+        BilinearWeightType nTempFY = rCtx.maMapFY[ nY ];
+        Scanline pScanline = rCtx.mpDest->GetScanline( nY );
+
+        for( sal_Int32 nX = nStartX, nXDst = 0; nX <= nEndX; nX++ )
+        {
+            sal_Int32 nTempX = rCtx.maMapIX[ nX ];
+            BilinearWeightType nTempFX = rCtx.maMapFX[ nX ];
+
+            BitmapColor aCol0 = rCtx.mpSrc->GetPaletteColor( rCtx.mpSrc->GetPixelIndex( nTempY, nTempX ) );
+            BitmapColor aCol1 = rCtx.mpSrc->GetPaletteColor( rCtx.mpSrc->GetPixelIndex( nTempY, ++nTempX ) );
+            sal_uInt8 cR0 = MAP( aCol0.GetRed(), aCol1.GetRed(), nTempFX );
+            sal_uInt8 cG0 = MAP( aCol0.GetGreen(), aCol1.GetGreen(), nTempFX );
+            sal_uInt8 cB0 = MAP( aCol0.GetBlue(), aCol1.GetBlue(), nTempFX );
+
+            aCol1 = rCtx.mpSrc->GetPaletteColor( rCtx.mpSrc->GetPixelIndex( ++nTempY, nTempX ) );
+            aCol0 = rCtx.mpSrc->GetPaletteColor( rCtx.mpSrc->GetPixelIndex( nTempY--, --nTempX ) );
+            sal_uInt8 cR1 = MAP( aCol0.GetRed(), aCol1.GetRed(), nTempFX );
+            sal_uInt8 cG1 = MAP( aCol0.GetGreen(), aCol1.GetGreen(), nTempFX );
+            sal_uInt8 cB1 = MAP( aCol0.GetBlue(), aCol1.GetBlue(), nTempFX );
+
+            BitmapColor aColRes( MAP( cR0, cR1, nTempFY ),
+                    MAP( cG0, cG1, nTempFY ),
+                    MAP( cB0, cB1, nTempFY ) );
+            rCtx.mpDest->SetPixelOnData( pScanline, nXDst++, aColRes );
+        }
+    }
+}
+
+void scaleUpNonPaletteGeneral(const ScaleContext &rCtx, sal_Int32 nStartY, sal_Int32 nEndY)
+{
+    const sal_Int32 nStartX = 0, nEndX = rCtx.mnDestW - 1;
+
+    for( sal_Int32 nY = nStartY; nY <= nEndY; nY++ )
+    {
+        sal_Int32 nTempY = rCtx.maMapIY[ nY ];
+        BilinearWeightType nTempFY = rCtx.maMapFY[ nY ];
+        Scanline pScanDest = rCtx.mpDest->GetScanline( nY );
+
+        for( sal_Int32 nX = nStartX, nXDst = 0; nX <= nEndX; nX++ )
+        {
+            sal_Int32 nTempX = rCtx.maMapIX[ nX ];
+            BilinearWeightType nTempFX = rCtx.maMapFX[ nX ];
+
+            BitmapColor aCol0 = rCtx.mpSrc->GetPixel( nTempY, nTempX );
+            BitmapColor aCol1 = rCtx.mpSrc->GetPixel( nTempY, ++nTempX );
+            sal_uInt8 cR0 = MAP( aCol0.GetRed(), aCol1.GetRed(), nTempFX );
+            sal_uInt8 cG0 = MAP( aCol0.GetGreen(), aCol1.GetGreen(), nTempFX );
+            sal_uInt8 cB0 = MAP( aCol0.GetBlue(), aCol1.GetBlue(), nTempFX );
+
+            aCol1 = rCtx.mpSrc->GetPixel( ++nTempY, nTempX );
+            aCol0 = rCtx.mpSrc->GetPixel( nTempY--, --nTempX );
+            sal_uInt8 cR1 = MAP( aCol0.GetRed(), aCol1.GetRed(), nTempFX );
+            sal_uInt8 cG1 = MAP( aCol0.GetGreen(), aCol1.GetGreen(), nTempFX );
+            sal_uInt8 cB1 = MAP( aCol0.GetBlue(), aCol1.GetBlue(), nTempFX );
+
+            BitmapColor aColRes( MAP( cR0, cR1, nTempFY ),
+                    MAP( cG0, cG1, nTempFY ),
+                    MAP( cB0, cB1, nTempFY ) );
+            rCtx.mpDest->SetPixelOnData( pScanDest, nXDst++, aColRes );
+        }
+    }
+}
+
+void scaleDownPalette8bit(const ScaleContext &rCtx, sal_Int32 nStartY, sal_Int32 nEndY)
+{
+    const sal_Int32 nStartX = 0, nEndX = rCtx.mnDestW - 1;
+
+    for( sal_Int32 nY = nStartY; nY <= nEndY; nY++ )
+    {
+        sal_Int32 nTop = rCtx.mbVMirr ? ( nY + 1 ) : nY;
+        sal_Int32 nBottom = rCtx.mbVMirr ? nY : ( nY + 1 ) ;
+
+        sal_Int32 nLineStart, nLineRange;
+        if( nY == nEndY )
+        {
+            nLineStart = rCtx.maMapIY[ nY ];
+            nLineRange = 0;
+        }
+        else
+        {
+            nLineStart = rCtx.maMapIY[ nTop ] ;
+            nLineRange = ( rCtx.maMapIY[ nBottom ] == rCtx.maMapIY[ nTop ] ) ? 1 :( rCtx.maMapIY[ nBottom ] - rCtx.maMapIY[ nTop ] );
+        }
+
+        Scanline pScanDest = rCtx.mpDest->GetScanline( nY );
+        for( sal_Int32 nX = nStartX , nXDst = 0; nX <= nEndX; nX++ )
+        {
+            sal_Int32 nLeft = rCtx.mbHMirr ? ( nX + 1 ) : nX;
+            sal_Int32 nRight = rCtx.mbHMirr ? nX : ( nX + 1 ) ;
+
+            sal_Int32 nRowStart;
+            sal_Int32 nRowRange;
+            if( nX == nEndX )
+            {
+                nRowStart = rCtx.maMapIX[ nX ];
+                nRowRange = 0;
+            }
+            else
+            {
+                nRowStart = rCtx.maMapIX[ nLeft ];
+                nRowRange = ( rCtx.maMapIX[ nRight ] == rCtx.maMapIX[ nLeft ] )? 1 : ( rCtx.maMapIX[ nRight ] - rCtx.maMapIX[ nLeft ] );
+            }
+
+            int nSumR = 0;
+            int nSumG = 0;
+            int nSumB = 0;
+            BilinearWeightType nTotalWeightY = 0;
+
+            for(sal_Int32 i = 0; i<= nLineRange; i++)
+            {
+                Scanline pTmpY = rCtx.mpSrc->GetScanline( nLineStart + i );
+                int nSumRowR = 0;
+                int nSumRowG = 0;
+                int nSumRowB = 0;
+                BilinearWeightType nTotalWeightX = 0;
+
+                for(sal_Int32 j = 0; j <= nRowRange; j++)
+                {
+                    const BitmapColor& rCol = rCtx.mpSrc->GetPaletteColor( pTmpY[ nRowStart + j ] );
+
+                    if(nX == nEndX )
+                    {
+                        nSumRowB += rCol.GetBlue() << MAP_PRECISION;
+                        nSumRowG += rCol.GetGreen() << MAP_PRECISION;
+                        nSumRowR += rCol.GetRed() << MAP_PRECISION;
+                        nTotalWeightX += lclMaxWeight();
+                    }
+                    else if( j == 0 )
+                    {
+                        BilinearWeightType nWeightX = lclMaxWeight() - rCtx.maMapFX[ nLeft ];
+                        nSumRowB += ( nWeightX *rCol.GetBlue()) ;
+                        nSumRowG += ( nWeightX *rCol.GetGreen()) ;
+                        nSumRowR += ( nWeightX *rCol.GetRed()) ;
+                        nTotalWeightX += nWeightX;
+                    }
+                    else if ( nRowRange == j )
+                    {
+                        BilinearWeightType nWeightX = rCtx.maMapFX[ nRight ] ;
+                        nSumRowB += ( nWeightX *rCol.GetBlue() );
+                        nSumRowG += ( nWeightX *rCol.GetGreen() );
+                        nSumRowR += ( nWeightX *rCol.GetRed() );
+                        nTotalWeightX += nWeightX;
+                    }
+                    else
+                    {
+                        nSumRowB += rCol.GetBlue() << MAP_PRECISION;
+                        nSumRowG += rCol.GetGreen() << MAP_PRECISION;
+                        nSumRowR += rCol.GetRed() << MAP_PRECISION;
+                        nTotalWeightX += lclMaxWeight();
+                    }
+                }
+
+                BilinearWeightType nWeightY = lclMaxWeight();
+                if( nY == nEndY )
+                    nWeightY = lclMaxWeight();
+                else if( i == 0 )
+                    nWeightY = lclMaxWeight() - rCtx.maMapFY[ nTop ];
+                else if( nLineRange == 1 )
+                    nWeightY = rCtx.maMapFY[ nTop ];
+                else if ( nLineRange == i )
+                    nWeightY = rCtx.maMapFY[ nBottom ];
+
+                if (nTotalWeightX)
+                {
+                    nSumRowB /= nTotalWeightX;
+                    nSumRowG /= nTotalWeightX;
+                    nSumRowR /= nTotalWeightX;
+                }
+
+                nSumB += nWeightY * nSumRowB;
+                nSumG += nWeightY * nSumRowG;
+                nSumR += nWeightY * nSumRowR;
+                nTotalWeightY += nWeightY;
+            }
+
+            if (nTotalWeightY)
+            {
+                nSumR /= nTotalWeightY;
+                nSumG /= nTotalWeightY;
+                nSumB /= nTotalWeightY;
+            }
+
+            BitmapColor aColRes(static_cast<sal_uInt8>(nSumR), static_cast<sal_uInt8>(nSumG), static_cast<sal_uInt8>(nSumB));
+            rCtx.mpDest->SetPixelOnData( pScanDest, nXDst++, aColRes );
+        }
+    }
+}
+
+void scaleDownPaletteGeneral(const ScaleContext &rCtx, sal_Int32 nStartY, sal_Int32 nEndY)
+{
+    const sal_Int32 nStartX = 0, nEndX = rCtx.mnDestW - 1;
+
+    for( sal_Int32 nY = nStartY; nY <= nEndY; nY++ )
+    {
+        sal_Int32 nTop = rCtx.mbVMirr ? ( nY + 1 ) : nY;
+        sal_Int32 nBottom = rCtx.mbVMirr ? nY : ( nY + 1 ) ;
+
+        sal_Int32 nLineStart, nLineRange;
+        if( nY ==nEndY )
+        {
+            nLineStart = rCtx.maMapIY[ nY ];
+            nLineRange = 0;
+        }
+        else
+        {
+            nLineStart = rCtx.maMapIY[ nTop ] ;
+            nLineRange = ( rCtx.maMapIY[ nBottom ] == rCtx.maMapIY[ nTop ] ) ? 1 :( rCtx.maMapIY[ nBottom ] - rCtx.maMapIY[ nTop ] );
+        }
+
+        Scanline pScanDest = rCtx.mpDest->GetScanline( nY );
+        for( sal_Int32 nX = nStartX , nXDst = 0; nX <= nEndX; nX++ )
+        {
+            sal_Int32 nLeft = rCtx.mbHMirr ? ( nX + 1 ) : nX;
+            sal_Int32 nRight = rCtx.mbHMirr ? nX : ( nX + 1 ) ;
+
+            sal_Int32 nRowStart, nRowRange;
+            if( nX == nEndX )
+            {
+                nRowStart = rCtx.maMapIX[ nX ];
+                nRowRange = 0;
+            }
+            else
+            {
+                nRowStart = rCtx.maMapIX[ nLeft ];
+                nRowRange = ( rCtx.maMapIX[ nRight ] == rCtx.maMapIX[ nLeft ] )? 1 : ( rCtx.maMapIX[ nRight ] - rCtx.maMapIX[ nLeft ] );
+            }
+
+            int nSumR = 0;
+            int nSumG = 0;
+            int nSumB = 0;
+            BilinearWeightType nTotalWeightY = 0;
+
+            for(sal_Int32 i = 0; i<= nLineRange; i++)
+            {
+                int nSumRowR = 0;
+                int nSumRowG = 0;
+                int nSumRowB = 0;
+                BilinearWeightType nTotalWeightX = 0;
+
+                Scanline pScanlineSrc = rCtx.mpSrc->GetScanline( nLineStart + i );
+                for(sal_Int32 j = 0; j <= nRowRange; j++)
+                {
+                    BitmapColor aCol0 = rCtx.mpSrc->GetPaletteColor ( rCtx.mpSrc->GetIndexFromData( pScanlineSrc, nRowStart + j ) );
+
+                    if(nX == nEndX )
+                    {
+
+                        nSumRowB += aCol0.GetBlue() << MAP_PRECISION;
+                        nSumRowG += aCol0.GetGreen() << MAP_PRECISION;
+                        nSumRowR += aCol0.GetRed() << MAP_PRECISION;
+                        nTotalWeightX += lclMaxWeight();
+                    }
+                    else if( j == 0 )
+                    {
+
+                        BilinearWeightType nWeightX = lclMaxWeight() - rCtx.maMapFX[ nLeft ];
+                        nSumRowB += ( nWeightX *aCol0.GetBlue()) ;
+                        nSumRowG += ( nWeightX *aCol0.GetGreen()) ;
+                        nSumRowR += ( nWeightX *aCol0.GetRed()) ;
+                        nTotalWeightX += nWeightX;
+                    }
+                    else if ( nRowRange == j )
+                    {
+
+                        BilinearWeightType nWeightX = rCtx.maMapFX[ nRight ] ;
+                        nSumRowB += ( nWeightX *aCol0.GetBlue() );
+                        nSumRowG += ( nWeightX *aCol0.GetGreen() );
+                        nSumRowR += ( nWeightX *aCol0.GetRed() );
+                        nTotalWeightX += nWeightX;
+                    }
+                    else
+                    {
+
+                        nSumRowB += aCol0.GetBlue() << MAP_PRECISION;
+                        nSumRowG += aCol0.GetGreen() << MAP_PRECISION;
+                        nSumRowR += aCol0.GetRed() << MAP_PRECISION;
+                        nTotalWeightX += lclMaxWeight();
+                    }
+                }
+
+                sal_Int32 nWeightY = lclMaxWeight();
+                if( nY == nEndY )
+                    nWeightY = lclMaxWeight();
+                else if( i == 0 )
+                    nWeightY = lclMaxWeight() - rCtx.maMapFY[ nTop ];
+                else if( nLineRange == 1 )
+                    nWeightY = rCtx.maMapFY[ nTop ];
+                else if ( nLineRange == i )
+                    nWeightY = rCtx.maMapFY[ nBottom ];
+
+                if (nTotalWeightX)
+                {
+                    nSumRowB /= nTotalWeightX;
+                    nSumRowG /= nTotalWeightX;
+                    nSumRowR /= nTotalWeightX;
+                }
+
+                nSumB += nWeightY * nSumRowB;
+                nSumG += nWeightY * nSumRowG;
+                nSumR += nWeightY * nSumRowR;
+                nTotalWeightY += nWeightY;
+            }
+
+            if (nTotalWeightY)
+            {
+                nSumR /= nTotalWeightY;
+                nSumG /= nTotalWeightY;
+                nSumB /= nTotalWeightY;
+            }
+
+            BitmapColor aColRes(static_cast<sal_uInt8>(nSumR), static_cast<sal_uInt8>(nSumG), static_cast<sal_uInt8>(nSumB));
+            rCtx.mpDest->SetPixelOnData( pScanDest, nXDst++, aColRes );
+        }
+    }
+}
+
+void scaleDownNonPaletteGeneral(const ScaleContext &rCtx, sal_Int32 nStartY, sal_Int32 nEndY)
+{
+    const sal_Int32 nStartX = 0, nEndX = rCtx.mnDestW - 1;
+
+    for( sal_Int32 nY = nStartY; nY <= nEndY; nY++ )
+    {
+        sal_Int32 nTop = rCtx.mbVMirr ? ( nY + 1 ) : nY;
+        sal_Int32 nBottom = rCtx.mbVMirr ? nY : ( nY + 1 ) ;
+
+        sal_Int32 nLineStart, nLineRange;
+        if( nY ==nEndY )
+        {
+            nLineStart = rCtx.maMapIY[ nY ];
+            nLineRange = 0;
+        }
+        else
+        {
+            nLineStart = rCtx.maMapIY[ nTop ] ;
+            nLineRange = ( rCtx.maMapIY[ nBottom ] == rCtx.maMapIY[ nTop ] ) ? 1 :( rCtx.maMapIY[ nBottom ] - rCtx.maMapIY[ nTop ] );
+        }
+
+        Scanline pScanDest = rCtx.mpDest->GetScanline( nY );
+        for( sal_Int32 nX = nStartX , nXDst = 0; nX <= nEndX; nX++ )
+        {
+            sal_Int32 nLeft = rCtx.mbHMirr ? ( nX + 1 ) : nX;
+            sal_Int32 nRight = rCtx.mbHMirr ? nX : ( nX + 1 ) ;
+
+            sal_Int32 nRowStart, nRowRange;
+            if( nX == nEndX )
+            {
+                nRowStart = rCtx.maMapIX[ nX ];
+                nRowRange = 0;
+            }
+            else
+            {
+                nRowStart = rCtx.maMapIX[ nLeft ];
+                nRowRange = ( rCtx.maMapIX[ nRight ] == rCtx.maMapIX[ nLeft ] )? 1 : ( rCtx.maMapIX[ nRight ] - rCtx.maMapIX[ nLeft ] );
+            }
+
+            int nSumR = 0;
+            int nSumG = 0;
+            int nSumB = 0;
+            BilinearWeightType nTotalWeightY = 0;
+
+            for(sal_Int32 i = 0; i<= nLineRange; i++)
+            {
+                int nSumRowR = 0;
+                int nSumRowG = 0;
+                int nSumRowB = 0;
+                BilinearWeightType nTotalWeightX = 0;
+
+                Scanline pScanlineSrc = rCtx.mpSrc->GetScanline( nLineStart + i );
+                for(sal_Int32 j = 0; j <= nRowRange; j++)
+                {
+                    BitmapColor aCol0 = rCtx.mpSrc->GetPixelFromData( pScanlineSrc, nRowStart + j );
+
+                    if(nX == nEndX )
+                    {
+
+                        nSumRowB += aCol0.GetBlue() << MAP_PRECISION;
+                        nSumRowG += aCol0.GetGreen() << MAP_PRECISION;
+                        nSumRowR += aCol0.GetRed() << MAP_PRECISION;
+                        nTotalWeightX += lclMaxWeight();
+                    }
+                    else if( j == 0 )
+                    {
+
+                        BilinearWeightType nWeightX = lclMaxWeight() - rCtx.maMapFX[ nLeft ];
+                        nSumRowB += ( nWeightX *aCol0.GetBlue()) ;
+                        nSumRowG += ( nWeightX *aCol0.GetGreen()) ;
+                        nSumRowR += ( nWeightX *aCol0.GetRed()) ;
+                        nTotalWeightX += nWeightX;
+                    }
+                    else if ( nRowRange == j )
+                    {
+
+                        BilinearWeightType nWeightX = rCtx.maMapFX[ nRight ] ;
+                        nSumRowB += ( nWeightX *aCol0.GetBlue() );
+                        nSumRowG += ( nWeightX *aCol0.GetGreen() );
+                        nSumRowR += ( nWeightX *aCol0.GetRed() );
+                        nTotalWeightX += nWeightX;
+                    }
+                    else
+                    {
+                        nSumRowB += aCol0.GetBlue() << MAP_PRECISION;
+                        nSumRowG += aCol0.GetGreen() << MAP_PRECISION;
+                        nSumRowR += aCol0.GetRed() << MAP_PRECISION;
+                        nTotalWeightX += lclMaxWeight();
+                    }
+                }
+
+                BilinearWeightType nWeightY = lclMaxWeight();
+                if( nY == nEndY )
+                    nWeightY = lclMaxWeight();
+                else if( i == 0 )
+                    nWeightY = lclMaxWeight() - rCtx.maMapFY[ nTop ];
+                else if( nLineRange == 1 )
+                    nWeightY = rCtx.maMapFY[ nTop ];
+                else if ( nLineRange == i )
+                    nWeightY = rCtx.maMapFY[ nBottom ];
+
+                if (nTotalWeightX)
+                {
+                    nSumRowB /= nTotalWeightX;
+                    nSumRowG /= nTotalWeightX;
+                    nSumRowR /= nTotalWeightX;
+                }
+
+                nSumB += nWeightY * nSumRowB;
+                nSumG += nWeightY * nSumRowG;
+                nSumR += nWeightY * nSumRowR;
+                nTotalWeightY += nWeightY;
+            }
+
+            if (nTotalWeightY)
+            {
+                nSumR /= nTotalWeightY;
+                nSumG /= nTotalWeightY;
+                nSumB /= nTotalWeightY;
+            }
+
+            BitmapColor aColRes(static_cast<sal_uInt8>(nSumR), static_cast<sal_uInt8>(nSumG), static_cast<sal_uInt8>(nSumB));
+            rCtx.mpDest->SetPixelOnData( pScanDest, nXDst++, aColRes );
+        }
+    }
+}
+
+} // end anonymous namespace
+
+BitmapScaleSuperFilter::BitmapScaleSuperFilter(const double& rScaleX, const double& rScaleY) :
+    mrScaleX(rScaleX),
+    mrScaleY(rScaleY)
+{}
+
+BitmapScaleSuperFilter::~BitmapScaleSuperFilter()
+{}
+
+BitmapEx BitmapScaleSuperFilter::execute(BitmapEx const& rBitmap) const
+{
+    Bitmap aBitmap(rBitmap.GetBitmap());
+    bool bRet = false;
+
+    const Size aSizePix(rBitmap.GetSizePixel());
+
+    bool bHMirr = mrScaleX < 0;
+    bool bVMirr = mrScaleY < 0;
+
+    double fScaleX = std::fabs(mrScaleX);
+    double fScaleY = std::fabs(mrScaleY);
+
+    const sal_Int32 nDstW = FRound(aSizePix.Width()  * fScaleX);
+    const sal_Int32 nDstH = FRound(aSizePix.Height() * fScaleY);
+
+    constexpr double fScaleThresh = 0.6;
+
+    if (nDstW <= 1 || nDstH <= 1)
+        return BitmapEx();
+
+    // check cache for a previously scaled version of this
+    ScaleCacheKey aKey(aBitmap.ImplGetSalBitmap().get(),
+                       Size(nDstW, nDstH));
+
+    ImplSVData* pSVData = ImplGetSVData();
+    auto& rCache = pSVData->maGDIData.maScaleCache;
+    auto aFind = rCache.find(aKey);
+    if (aFind != rCache.end())
+    {
+        if (aFind->second.GetSizePixel().Width() == nDstW && aFind->second.GetSizePixel().Height() == nDstH)
+            return aFind->second;
+        else
+            SAL_WARN("vcl.gdi", "Error: size mismatch in scale cache");
+    }
+
+    {
+        BitmapScopedReadAccess pReadAccess(aBitmap);
+
+        // If source format is less than 24BPP, use 24BPP
+        auto eSourcePixelFormat = aBitmap.getPixelFormat();
+        auto ePixelFormat = eSourcePixelFormat;
+        if (sal_uInt16(eSourcePixelFormat) < 24)
+            ePixelFormat = vcl::PixelFormat::N24_BPP;
+
+        Bitmap aOutBmp(Size(nDstW, nDstH), ePixelFormat);
+        Size aOutSize = aOutBmp.GetSizePixel();
+        auto eTargetPixelFormat = aOutBmp.getPixelFormat();
+
+        if (!aOutSize.Width() || !aOutSize.Height())
+        {
+            SAL_WARN("vcl.gdi", "bmp creation failed");
+            return BitmapEx();
+        }
+
+        BitmapScopedWriteAccess pWriteAccess(aOutBmp);
+
+        const sal_Int32 nEndY   = nDstH - 1;
+
+        if (pReadAccess && pWriteAccess)
+        {
+            ScaleRangeFn pScaleRangeFn;
+            const ScaleContext aContext( pReadAccess.get(),
+                                   pWriteAccess.get(),
+                                   pReadAccess->Width(),
+                                   pWriteAccess->Width(),
+                                   pReadAccess->Height(),
+                                   pWriteAccess->Height(),
+                                   bVMirr, bHMirr );
+
+            bool bScaleUp = fScaleX >= fScaleThresh && fScaleY >= fScaleThresh;
+            // If we have a source bitmap with a palette the scaling converts
+            // from up to 8 bit image -> 24 bit non-palette, which is then
+            // adapted back to the same type as original.
+            if (pReadAccess->HasPalette())
+            {
+                switch( pReadAccess->GetScanlineFormat() )
+                {
+                case ScanlineFormat::N8BitPal:
+                    pScaleRangeFn = bScaleUp ? scaleUpPalette8bit
+                                             : scaleDownPalette8bit;
+                    break;
+                default:
+                    pScaleRangeFn = bScaleUp ? scaleUpPaletteGeneral
+                                             : scaleDownPaletteGeneral;
+                    break;
+                }
+            }
+            // Here we know that we are dealing with a non-palette source bitmap.
+            // The target is either 24 or 32 bit, depending on the image and
+            // the capabilities of the backend. If for some reason the destination
+            // is not the same bit-depth as the source, then we can't use
+            // a fast path, so we always need to process with a general scaler.
+            else if (eSourcePixelFormat != eTargetPixelFormat)
+            {
+                pScaleRangeFn = bScaleUp ? scaleUpNonPaletteGeneral : scaleDownNonPaletteGeneral;
+            }
+            // If we get here then we can only use a fast path, but let's
+            // still keep the fallback to the general scaler alive.
+            else
+            {
+                switch( pReadAccess->GetScanlineFormat() )
+                {
+                case ScanlineFormat::N24BitTcBgr:
+                case ScanlineFormat::N24BitTcRgb:
+                    pScaleRangeFn = bScaleUp ? scaleUp<24> : scaleDown<24>;
+                    break;
+                case ScanlineFormat::N32BitTcRgba:
+                case ScanlineFormat::N32BitTcBgra:
+                case ScanlineFormat::N32BitTcArgb:
+                case ScanlineFormat::N32BitTcAbgr:
+                    pScaleRangeFn = bScaleUp ? scaleUp<32> : scaleDown<32>;
+                    break;
+                default:
+                    pScaleRangeFn = bScaleUp ? scaleUpNonPaletteGeneral
+                                             : scaleDownNonPaletteGeneral;
+                    break;
+                }
+            }
+
+            // We want to thread - only if there is a lot of work to do:
+            // We work hard when there is a large destination image, or
+            // A large source image.
+            bool bHorizontalWork = pReadAccess->Height() >= 512 && pReadAccess->Width() >= 512;
+            bool bUseThreads = true;
+            const sal_Int32 nStartY = 0;
+
+            static bool bDisableThreadedScaling = getenv ("VCL_NO_THREAD_SCALE");
+            if (bDisableThreadedScaling || !bHorizontalWork)
+            {
+                SAL_INFO("vcl.gdi", "Scale in main thread");
+                bUseThreads = false;
+            }
+
+            if (bUseThreads)
+            {
+                try
+                {
+                    // partition and queue work
+                    comphelper::ThreadPool &rShared = comphelper::ThreadPool::getSharedOptimalPool();
+                    std::shared_ptr<comphelper::ThreadTaskTag> pTag = comphelper::ThreadPool::createThreadTaskTag();
+
+                    vcl::bitmap::generateStripRanges<constScaleThreadStrip>(nStartY, nEndY,
+                    [&] (sal_Int32 const nStart, sal_Int32 const nEnd, bool const bLast)
+                    {
+                        if (!bLast)
+                        {
+                            auto pTask(std::make_unique<ScaleTask>(pTag, pScaleRangeFn, aContext, nStart, nEnd));
+                            rShared.pushTask(std::move(pTask));
+                        }
+                        else
+                            pScaleRangeFn(aContext, nStart, nEnd);
+                    });
+                    rShared.waitUntilDone(pTag);
+                    SAL_INFO("vcl.gdi", "All threaded scaling tasks complete");
+                }
+                catch (...)
+                {
+                    SAL_WARN("vcl.gdi", "threaded bitmap scaling failed");
+                    bUseThreads = false;
+                }
+            }
+
+            if (!bUseThreads)
+                pScaleRangeFn( aContext, nStartY, nEndY );
+
+            pWriteAccess.reset();
+            bRet = true;
+            aBitmap.AdaptBitCount(aOutBmp);
+            aBitmap = aOutBmp;
+        }
+    }
+
+    if (bRet)
+    {
+        tools::Rectangle aRect(Point(0, 0), Point(nDstW, nDstH));
+        aBitmap.Crop(aRect);
+        BitmapEx aRet(aBitmap);
+        rCache.insert(std::make_pair(aKey, aRet));
+        return aRet;
+    }
+
+    return BitmapEx();
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapSeparableUnsharpenFilter.cxx b/vcl/source/bitmap/BitmapSeparableUnsharpenFilter.cxx
new file mode 100644
index 0000000000..a65cd6ee56
--- /dev/null
+++ b/vcl/source/bitmap/BitmapSeparableUnsharpenFilter.cxx
@@ -0,0 +1,75 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <tools/helpers.hxx>
+
+#include <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapGaussianSeparableBlurFilter.hxx>
+#include <vcl/BitmapSeparableUnsharpenFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+BitmapEx BitmapSeparableUnsharpenFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+    const sal_Int32 nWidth = aBitmap.GetSizePixel().Width();
+    const sal_Int32 nHeight = aBitmap.GetSizePixel().Height();
+
+    Bitmap aBlur(aBitmap);
+    BitmapEx aBlurEx(aBlur);
+
+    BitmapFilter::Filter(aBlurEx, BitmapGaussianSeparableBlurFilter(-mfRadius));
+    aBlur = aBlurEx.GetBitmap();
+
+    // Amount of unsharpening effect on image - currently set to a fixed value
+    double aAmount = 2.0;
+
+    Bitmap aResultBitmap(Size(nWidth, nHeight), vcl::PixelFormat::N24_BPP);
+
+    BitmapScopedReadAccess pReadAccBlur(aBlur);
+    BitmapScopedReadAccess pReadAcc(aBitmap);
+    BitmapScopedWriteAccess pWriteAcc(aResultBitmap);
+
+    BitmapColor aColor, aColorBlur;
+
+    // For all pixels in original image subtract pixels values from blurred image
+    for (sal_Int32 y = 0; y < nHeight; y++)
+    {
+        Scanline pScanline = pWriteAcc->GetScanline(y);
+        for (sal_Int32 x = 0; x < nWidth; x++)
+        {
+            aColorBlur = pReadAccBlur->GetColor(y, x);
+            aColor = pReadAcc->GetColor(y, x);
+
+            BitmapColor aResultColor(
+                static_cast<sal_uInt8>(
+                    std::clamp(aColor.GetRed() + (aColor.GetRed() - aColorBlur.GetRed()) * aAmount,
+                               0.0, 255.0)),
+                static_cast<sal_uInt8>(std::clamp(
+                    aColor.GetGreen() + (aColor.GetGreen() - aColorBlur.GetGreen()) * aAmount, 0.0,
+                    255.0)),
+                static_cast<sal_uInt8>(std::clamp(
+                    aColor.GetBlue() + (aColor.GetBlue() - aColorBlur.GetBlue()) * aAmount, 0.0,
+                    255.0)));
+
+            pWriteAcc->SetPixelOnData(pScanline, x, aResultColor);
+        }
+    }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+    pReadAccBlur.reset();
+    aBitmap.ReassignWithSize(aResultBitmap);
+
+    return BitmapEx(aBitmap);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapSepiaFilter.cxx b/vcl/source/bitmap/BitmapSepiaFilter.cxx
new file mode 100644
index 0000000000..fdc5a8a722
--- /dev/null
+++ b/vcl/source/bitmap/BitmapSepiaFilter.cxx
@@ -0,0 +1,98 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <sal/config.h>
+
+#include <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapSepiaFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+#include <algorithm>
+
+BitmapEx BitmapSepiaFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+    BitmapScopedReadAccess pReadAcc(aBitmap);
+    if (!pReadAcc)
+        return BitmapEx();
+
+    const sal_Int32 nSepia
+        = 10000 - 100 * std::clamp(mnSepiaPercent, sal_uInt16(0), sal_uInt16(100));
+    BitmapPalette aSepiaPal(256);
+
+    for (sal_uInt16 i = 0; i < 256; i++)
+    {
+        BitmapColor& rCol = aSepiaPal[i];
+        const sal_uInt8 cSepiaValue = static_cast<sal_uInt8>(nSepia * i / 10000);
+
+        rCol.SetRed(static_cast<sal_uInt8>(i));
+        rCol.SetGreen(cSepiaValue);
+        rCol.SetBlue(cSepiaValue);
+    }
+
+    Bitmap aNewBmp(aBitmap.GetSizePixel(), vcl::PixelFormat::N8_BPP, &aSepiaPal);
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if (!pWriteAcc)
+        return BitmapEx();
+
+    BitmapColor aCol(sal_uInt8(0));
+    const sal_Int32 nWidth = pWriteAcc->Width();
+    const sal_Int32 nHeight = pWriteAcc->Height();
+
+    if (pReadAcc->HasPalette())
+    {
+        const sal_uInt16 nPalCount = pReadAcc->GetPaletteEntryCount();
+        std::unique_ptr<sal_uInt8[]> pIndexMap(new sal_uInt8[nPalCount]);
+        for (sal_uInt16 i = 0; i < nPalCount; i++)
+        {
+            pIndexMap[i] = pReadAcc->GetPaletteColor(i).GetLuminance();
+        }
+
+        for (sal_Int32 nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+            for (sal_Int32 nX = 0; nX < nWidth; nX++)
+            {
+                aCol.SetIndex(pIndexMap[pReadAcc->GetIndexFromData(pScanlineRead, nX)]);
+                pWriteAcc->SetPixelOnData(pScanline, nX, aCol);
+            }
+        }
+    }
+    else
+    {
+        for (sal_Int32 nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+            for (sal_Int32 nX = 0; nX < nWidth; nX++)
+            {
+                aCol.SetIndex(pReadAcc->GetPixelFromData(pScanlineRead, nX).GetLuminance());
+                pWriteAcc->SetPixelOnData(pScanline, nX, aCol);
+            }
+        }
+    }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+
+    const MapMode aMap(aBitmap.GetPrefMapMode());
+    const Size aPrefSize(aBitmap.GetPrefSize());
+
+    aBitmap = aNewBmp;
+
+    aBitmap.SetPrefMapMode(aMap);
+    aBitmap.SetPrefSize(aPrefSize);
+
+    return BitmapEx(aBitmap);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapShadowFilter.cxx b/vcl/source/bitmap/BitmapShadowFilter.cxx
new file mode 100644
index 0000000000..76da85b3bf
--- /dev/null
+++ b/vcl/source/bitmap/BitmapShadowFilter.cxx
@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <vcl/bitmapex.hxx>
+#include <vcl/BitmapColor.hxx>
+#include <vcl/BitmapShadowFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+BitmapEx BitmapShadowFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    BitmapEx aBitmapEx(rBitmapEx);
+    BitmapScopedWriteAccess pWriteAccess(const_cast<Bitmap&>(aBitmapEx.GetBitmap()));
+
+    if (!pWriteAccess)
+        return rBitmapEx;
+
+    for (sal_Int32 y(0); y < sal_Int32(pWriteAccess->Height()); y++)
+    {
+        Scanline pScanline = pWriteAccess->GetScanline(y);
+
+        for (sal_Int32 x(0); x < sal_Int32(pWriteAccess->Width()); x++)
+        {
+            const BitmapColor aColor = pWriteAccess->GetColor(y, x);
+            sal_uInt16 nLuminance(static_cast<sal_uInt16>(aColor.GetLuminance()) + 1);
+            const BitmapColor aDestColor(
+                static_cast<sal_uInt8>(
+                    (nLuminance * static_cast<sal_uInt16>(maShadowColor.GetRed())) >> 8),
+                static_cast<sal_uInt8>(
+                    (nLuminance * static_cast<sal_uInt16>(maShadowColor.GetGreen())) >> 8),
+                static_cast<sal_uInt8>(
+                    (nLuminance * static_cast<sal_uInt16>(maShadowColor.GetBlue())) >> 8));
+
+            pWriteAccess->SetPixelOnData(pScanline, x, aDestColor);
+        }
+    }
+
+    return aBitmapEx;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapSimpleColorQuantizationFilter.cxx b/vcl/source/bitmap/BitmapSimpleColorQuantizationFilter.cxx
new file mode 100644
index 0000000000..4dc045be2d
--- /dev/null
+++ b/vcl/source/bitmap/BitmapSimpleColorQuantizationFilter.cxx
@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapSimpleColorQuantizationFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+#include <bitmap/Octree.hxx>
+
+BitmapEx BitmapSimpleColorQuantizationFilter::execute(BitmapEx const& aBitmapEx) const
+{
+    Bitmap aBitmap = aBitmapEx.GetBitmap();
+
+    if (vcl::numberOfColors(aBitmap.getPixelFormat()) <= sal_Int64(mnNewColorCount))
+        return BitmapEx(aBitmap);
+
+    Bitmap aNewBmp;
+    BitmapScopedReadAccess pRAcc(aBitmap);
+    if (!pRAcc)
+        return BitmapEx();
+
+    const sal_uInt16 nColorCount = std::min(mnNewColorCount, sal_uInt16(256));
+    auto ePixelFormat = vcl::PixelFormat::N8_BPP;
+
+    Octree aOct(*pRAcc, nColorCount);
+    const BitmapPalette& rPal = aOct.GetPalette();
+
+    aNewBmp = Bitmap(aBitmap.GetSizePixel(), ePixelFormat, &rPal);
+    BitmapScopedWriteAccess pWAcc(aNewBmp);
+    if (!pWAcc)
+        return BitmapEx();
+
+    const sal_Int32 nWidth = pRAcc->Width();
+    const sal_Int32 nHeight = pRAcc->Height();
+
+    if (pRAcc->HasPalette())
+    {
+        for (sal_Int32 nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWAcc->GetScanline(nY);
+            Scanline pScanlineRead = pRAcc->GetScanline(nY);
+            for (sal_Int32 nX = 0; nX < nWidth; nX++)
+            {
+                auto c = pRAcc->GetPaletteColor(pRAcc->GetIndexFromData(pScanlineRead, nX));
+                pWAcc->SetPixelOnData(
+                    pScanline, nX,
+                    BitmapColor(static_cast<sal_uInt8>(aOct.GetBestPaletteIndex(c))));
+            }
+        }
+    }
+    else
+    {
+        for (sal_Int32 nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWAcc->GetScanline(nY);
+            Scanline pScanlineRead = pRAcc->GetScanline(nY);
+            for (sal_Int32 nX = 0; nX < nWidth; nX++)
+            {
+                auto c = pRAcc->GetPixelFromData(pScanlineRead, nX);
+                pWAcc->SetPixelOnData(
+                    pScanline, nX,
+                    BitmapColor(static_cast<sal_uInt8>(aOct.GetBestPaletteIndex(c))));
+            }
+        }
+    }
+
+    pWAcc.reset();
+    pRAcc.reset();
+
+    const MapMode aMap(aBitmap.GetPrefMapMode());
+    const Size aSize(aBitmap.GetPrefSize());
+
+    aBitmap = aNewBmp;
+
+    aBitmap.SetPrefMapMode(aMap);
+    aBitmap.SetPrefSize(aSize);
+
+    return BitmapEx(aBitmap);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapSmoothenFilter.cxx b/vcl/source/bitmap/BitmapSmoothenFilter.cxx
new file mode 100644
index 0000000000..e9c135f8ec
--- /dev/null
+++ b/vcl/source/bitmap/BitmapSmoothenFilter.cxx
@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <vcl/bitmapex.hxx>
+#include <vcl/BitmapGaussianSeparableBlurFilter.hxx>
+#include <vcl/BitmapSeparableUnsharpenFilter.hxx>
+#include <vcl/BitmapSmoothenFilter.hxx>
+
+BitmapEx BitmapSmoothenFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    BitmapEx aBitmapEx(rBitmapEx);
+    bool bRet = false;
+
+    if (mfRadius > 0.0) // Blur for positive values of mnRadius
+        bRet = BitmapFilter::Filter(aBitmapEx, BitmapGaussianSeparableBlurFilter(mfRadius));
+    else if (mfRadius < 0.0) // Unsharpen mask for negative values of mnRadius
+        bRet = BitmapFilter::Filter(aBitmapEx, BitmapSeparableUnsharpenFilter(mfRadius));
+
+    if (bRet)
+        return aBitmapEx;
+
+    return BitmapEx();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapSobelGreyFilter.cxx b/vcl/source/bitmap/BitmapSobelGreyFilter.cxx
new file mode 100644
index 0000000000..c1c6822757
--- /dev/null
+++ b/vcl/source/bitmap/BitmapSobelGreyFilter.cxx
@@ -0,0 +1,154 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <sal/config.h>
+
+#include <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapSobelGreyFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+#include <algorithm>
+
+BitmapEx BitmapSobelGreyFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+    if (!aBitmap.ImplMakeGreyscales())
+        return BitmapEx();
+
+    BitmapScopedReadAccess pReadAcc(aBitmap);
+    if (!pReadAcc)
+        return BitmapEx();
+
+    Bitmap aNewBmp(aBitmap.GetSizePixel(), vcl::PixelFormat::N8_BPP, &pReadAcc->GetPalette());
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if (!pWriteAcc)
+        return BitmapEx();
+
+    BitmapColor aGrey(sal_uInt8(0));
+    const sal_Int32 nWidth = pWriteAcc->Width();
+    const sal_Int32 nHeight = pWriteAcc->Height();
+    const sal_Int32 nMask111 = -1, nMask121 = 0, nMask131 = 1;
+    const sal_Int32 nMask211 = -2, nMask221 = 0, nMask231 = 2;
+    const sal_Int32 nMask311 = -1, nMask321 = 0, nMask331 = 1;
+    const sal_Int32 nMask112 = 1, nMask122 = 2, nMask132 = 1;
+    const sal_Int32 nMask212 = 0, nMask222 = 0, nMask232 = 0;
+    const sal_Int32 nMask312 = -1, nMask322 = -2, nMask332 = -1;
+    sal_Int32 nGrey11, nGrey12, nGrey13;
+    sal_Int32 nGrey21, nGrey22, nGrey23;
+    sal_Int32 nGrey31, nGrey32, nGrey33;
+    std::unique_ptr<long[]> pHMap(new long[nWidth + 2]);
+    std::unique_ptr<long[]> pVMap(new long[nHeight + 2]);
+    sal_Int32 nX, nY, nSum1, nSum2;
+
+    // fill mapping tables
+    pHMap[0] = 0;
+
+    for (nX = 1; nX <= nWidth; nX++)
+    {
+        pHMap[nX] = nX - 1;
+    }
+
+    pHMap[nWidth + 1] = nWidth - 1;
+
+    pVMap[0] = 0;
+
+    for (nY = 1; nY <= nHeight; nY++)
+    {
+        pVMap[nY] = nY - 1;
+    }
+
+    pVMap[nHeight + 1] = nHeight - 1;
+
+    for (nY = 0; nY < nHeight; nY++)
+    {
+        nGrey11 = pReadAcc->GetPixel(pVMap[nY], pHMap[0]).GetIndex();
+        nGrey12 = pReadAcc->GetPixel(pVMap[nY], pHMap[1]).GetIndex();
+        nGrey13 = pReadAcc->GetPixel(pVMap[nY], pHMap[2]).GetIndex();
+        nGrey21 = pReadAcc->GetPixel(pVMap[nY + 1], pHMap[0]).GetIndex();
+        nGrey22 = pReadAcc->GetPixel(pVMap[nY + 1], pHMap[1]).GetIndex();
+        nGrey23 = pReadAcc->GetPixel(pVMap[nY + 1], pHMap[2]).GetIndex();
+        nGrey31 = pReadAcc->GetPixel(pVMap[nY + 2], pHMap[0]).GetIndex();
+        nGrey32 = pReadAcc->GetPixel(pVMap[nY + 2], pHMap[1]).GetIndex();
+        nGrey33 = pReadAcc->GetPixel(pVMap[nY + 2], pHMap[2]).GetIndex();
+
+        Scanline pScanline = pWriteAcc->GetScanline(nY);
+        for (nX = 0; nX < nWidth; nX++)
+        {
+            nSum1 = nSum2 = 0;
+
+            nSum1 += nMask111 * nGrey11;
+            nSum2 += nMask112 * nGrey11;
+
+            nSum1 += nMask121 * nGrey12;
+            nSum2 += nMask122 * nGrey12;
+
+            nSum1 += nMask131 * nGrey13;
+            nSum2 += nMask132 * nGrey13;
+
+            nSum1 += nMask211 * nGrey21;
+            nSum2 += nMask212 * nGrey21;
+
+            nSum1 += nMask221 * nGrey22;
+            nSum2 += nMask222 * nGrey22;
+
+            nSum1 += nMask231 * nGrey23;
+            nSum2 += nMask232 * nGrey23;
+
+            nSum1 += nMask311 * nGrey31;
+            nSum2 += nMask312 * nGrey31;
+
+            nSum1 += nMask321 * nGrey32;
+            nSum2 += nMask322 * nGrey32;
+
+            nSum1 += nMask331 * nGrey33;
+            nSum2 += nMask332 * nGrey33;
+
+            nSum1 = static_cast<sal_Int32>(std::hypot(nSum1, nSum2));
+
+            aGrey.SetIndex(
+                ~static_cast<sal_uInt8>(std::clamp(nSum1, sal_Int32(0), sal_Int32(255))));
+            pWriteAcc->SetPixelOnData(pScanline, nX, aGrey);
+
+            if (nX < (nWidth - 1))
+            {
+                const sal_Int32 nNextX = pHMap[nX + 3];
+
+                nGrey11 = nGrey12;
+                nGrey12 = nGrey13;
+                nGrey13 = pReadAcc->GetPixel(pVMap[nY], nNextX).GetIndex();
+                nGrey21 = nGrey22;
+                nGrey22 = nGrey23;
+                nGrey23 = pReadAcc->GetPixel(pVMap[nY + 1], nNextX).GetIndex();
+                nGrey31 = nGrey32;
+                nGrey32 = nGrey33;
+                nGrey33 = pReadAcc->GetPixel(pVMap[nY + 2], nNextX).GetIndex();
+            }
+        }
+    }
+
+    pHMap.reset();
+    pVMap.reset();
+    pWriteAcc.reset();
+    pReadAcc.reset();
+
+    const MapMode aMap(aBitmap.GetPrefMapMode());
+    const Size aPrefSize(aBitmap.GetPrefSize());
+
+    aBitmap = aNewBmp;
+
+    aBitmap.SetPrefMapMode(aMap);
+    aBitmap.SetPrefSize(aPrefSize);
+
+    return BitmapEx(aBitmap);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapSolarizeFilter.cxx b/vcl/source/bitmap/BitmapSolarizeFilter.cxx
new file mode 100644
index 0000000000..ca2485a7f4
--- /dev/null
+++ b/vcl/source/bitmap/BitmapSolarizeFilter.cxx
@@ -0,0 +1,70 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/BitmapSolarizeFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+BitmapEx BitmapSolarizeFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+    bool bRet = false;
+    BitmapScopedWriteAccess pWriteAcc(aBitmap);
+
+    if (pWriteAcc)
+    {
+        if (pWriteAcc->HasPalette())
+        {
+            const BitmapPalette& rPal = pWriteAcc->GetPalette();
+
+            for (sal_uInt16 i = 0, nCount = rPal.GetEntryCount(); i < nCount; i++)
+            {
+                if (rPal[i].GetLuminance() >= mcSolarGreyThreshold)
+                {
+                    BitmapColor aCol(rPal[i]);
+                    aCol.Invert();
+                    pWriteAcc->SetPaletteColor(i, aCol);
+                }
+            }
+        }
+        else
+        {
+            BitmapColor aCol;
+            const sal_Int32 nWidth = pWriteAcc->Width();
+            const sal_Int32 nHeight = pWriteAcc->Height();
+
+            for (sal_Int32 nY = 0; nY < nHeight; nY++)
+            {
+                Scanline pScanline = pWriteAcc->GetScanline(nY);
+                for (sal_Int32 nX = 0; nX < nWidth; nX++)
+                {
+                    aCol = pWriteAcc->GetPixelFromData(pScanline, nX);
+
+                    if (aCol.GetLuminance() >= mcSolarGreyThreshold)
+                    {
+                        aCol.Invert();
+                        pWriteAcc->SetPixelOnData(pScanline, nX, aCol);
+                    }
+                }
+            }
+        }
+
+        pWriteAcc.reset();
+        bRet = true;
+    }
+
+    if (bRet)
+        return BitmapEx(aBitmap);
+
+    return BitmapEx();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapSymmetryCheck.cxx b/vcl/source/bitmap/BitmapSymmetryCheck.cxx
new file mode 100644
index 0000000000..26e035e8da
--- /dev/null
+++ b/vcl/source/bitmap/BitmapSymmetryCheck.cxx
@@ -0,0 +1,83 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <vcl/BitmapReadAccess.hxx>
+
+#include <BitmapSymmetryCheck.hxx>
+
+BitmapSymmetryCheck::BitmapSymmetryCheck()
+{}
+
+bool BitmapSymmetryCheck::check(Bitmap& rBitmap)
+{
+    BitmapScopedReadAccess aReadAccess(rBitmap);
+    return checkImpl(aReadAccess.get());
+}
+
+bool BitmapSymmetryCheck::checkImpl(BitmapReadAccess const * pReadAccess)
+{
+    tools::Long nHeight = pReadAccess->Height();
+    tools::Long nWidth = pReadAccess->Width();
+
+    tools::Long nHeightHalf = nHeight / 2;
+    tools::Long nWidthHalf = nWidth / 2;
+
+    bool bHeightEven = (nHeight % 2) == 0;
+    bool bWidthEven = (nWidth % 2) == 0;
+
+    for (tools::Long y = 0; y < nHeightHalf; ++y)
+    {
+        Scanline pScanlineRead = pReadAccess->GetScanline( y );
+        Scanline pScanlineRead2 = pReadAccess->GetScanline( nHeight - y - 1 );
+        for (tools::Long x = 0; x < nWidthHalf; ++x)
+        {
+            if (pReadAccess->GetPixelFromData(pScanlineRead, x) != pReadAccess->GetPixelFromData(pScanlineRead2, x))
+            {
+                return false;
+            }
+            if (pReadAccess->GetPixelFromData(pScanlineRead, x) != pReadAccess->GetPixelFromData(pScanlineRead, nWidth - x - 1))
+            {
+                return false;
+            }
+            if (pReadAccess->GetPixelFromData(pScanlineRead, x) != pReadAccess->GetPixelFromData(pScanlineRead2, nWidth - x - 1))
+            {
+                return false;
+            }
+        }
+    }
+
+    if (bWidthEven)
+    {
+        for (tools::Long y = 0; y < nHeightHalf; ++y)
+        {
+            if (pReadAccess->GetPixel(y, nWidthHalf) != pReadAccess->GetPixel(nHeight - y - 1, nWidthHalf))
+            {
+                return false;
+            }
+        }
+    }
+
+    if (bHeightEven)
+    {
+        Scanline pScanlineRead = pReadAccess->GetScanline( nHeightHalf );
+        for (tools::Long x = 0; x < nWidthHalf; ++x)
+        {
+            if (pReadAccess->GetPixelFromData(pScanlineRead, x) != pReadAccess->GetPixelFromData(pScanlineRead, nWidth - x - 1))
+            {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapTools.cxx b/vcl/source/bitmap/BitmapTools.cxx
new file mode 100644
index 0000000000..ee0134a900
--- /dev/null
+++ b/vcl/source/bitmap/BitmapTools.cxx
@@ -0,0 +1,1302 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <sal/config.h>
+
+#include <array>
+#include <utility>
+
+#include <tools/helpers.hxx>
+#include <vcl/BitmapTools.hxx>
+
+#include <sal/log.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/seqstream.hxx>
+#include <vcl/canvastools.hxx>
+#include <basegfx/matrix/b2dhommatrix.hxx>
+
+#include <com/sun/star/graphic/SvgTools.hpp>
+#include <com/sun/star/graphic/Primitive2DTools.hpp>
+
+#include <drawinglayer/primitive2d/baseprimitive2d.hxx>
+
+#include <com/sun/star/rendering/XIntegerReadOnlyBitmap.hpp>
+
+#include <vcl/dibtools.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/virdev.hxx>
+#if ENABLE_CAIRO_CANVAS
+#include <cairo.h>
+#endif
+#include <comphelper/diagnose_ex.hxx>
+#include <tools/fract.hxx>
+#include <tools/stream.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+
+using namespace css;
+
+using drawinglayer::primitive2d::Primitive2DSequence;
+using drawinglayer::primitive2d::Primitive2DReference;
+
+namespace vcl::bitmap
+{
+
+BitmapEx loadFromName(const OUString& rFileName, const ImageLoadFlags eFlags)
+{
+    bool bSuccess = true;
+    OUString aIconTheme;
+    BitmapEx aBitmapEx;
+    try
+    {
+        aIconTheme = Application::GetSettings().GetStyleSettings().DetermineIconTheme();
+        ImageTree::get().loadImage(rFileName, aIconTheme, aBitmapEx, true, eFlags);
+    }
+    catch (...)
+    {
+        bSuccess = false;
+    }
+
+    SAL_WARN_IF(!bSuccess, "vcl", "vcl::bitmap::loadFromName : could not load image " << rFileName << " via icon theme " << aIconTheme);
+
+    return aBitmapEx;
+}
+
+void loadFromSvg(SvStream& rStream, const OUString& sPath, BitmapEx& rBitmapEx, double fScalingFactor)
+{
+    uno::Reference<uno::XComponentContext> xContext(comphelper::getProcessComponentContext());
+    const uno::Reference<graphic::XSvgParser> xSvgParser = graphic::SvgTools::create(xContext);
+
+    std::size_t nSize = rStream.remainingSize();
+    std::vector<sal_Int8> aBuffer(nSize + 1);
+    rStream.ReadBytes(aBuffer.data(), nSize);
+    aBuffer[nSize] = 0;
+
+    uno::Sequence<sal_Int8> aData(aBuffer.data(), nSize + 1);
+    uno::Reference<io::XInputStream> aInputStream(new comphelper::SequenceInputStream(aData));
+
+    const Primitive2DSequence aPrimitiveSequence = xSvgParser->getDecomposition(aInputStream, sPath);
+
+    if (!aPrimitiveSequence.hasElements())
+        return;
+
+    uno::Sequence<beans::PropertyValue> aViewParameters;
+
+    geometry::RealRectangle2D aRealRect;
+    basegfx::B2DRange aRange;
+    for (css::uno::Reference<css::graphic::XPrimitive2D> const & xReference : aPrimitiveSequence)
+    {
+        if (xReference.is())
+        {
+            aRealRect = xReference->getRange(aViewParameters);
+            aRange.expand(basegfx::B2DRange(aRealRect.X1, aRealRect.Y1, aRealRect.X2, aRealRect.Y2));
+        }
+    }
+
+    aRealRect.X1 = aRange.getMinX();
+    aRealRect.Y1 = aRange.getMinY();
+    aRealRect.X2 = aRange.getMaxX();
+    aRealRect.Y2 = aRange.getMaxY();
+
+    double nDPI = 96 * fScalingFactor;
+
+    const css::uno::Reference<css::graphic::XPrimitive2DRenderer> xPrimitive2DRenderer = css::graphic::Primitive2DTools::create(xContext);
+    const css::uno::Reference<css::rendering::XBitmap> xBitmap(
+        xPrimitive2DRenderer->rasterize(aPrimitiveSequence, aViewParameters, nDPI, nDPI, aRealRect, 256*256));
+
+    if (xBitmap.is())
+    {
+        const css::uno::Reference<css::rendering::XIntegerReadOnlyBitmap> xIntBmp(xBitmap, uno::UNO_QUERY_THROW);
+        rBitmapEx = vcl::unotools::bitmapExFromXBitmap(xIntBmp);
+    }
+
+}
+
+/** Copy block of image data into the bitmap.
+    Assumes that the Bitmap has been constructed with the desired size.
+
+    @param pData
+    The block of data to copy
+    @param nStride
+    The number of bytes in a scanline, must >= (width * nBitCount / 8)
+    @param bReversColors
+    In case the endianness of pData is wrong, you could reverse colors
+*/
+BitmapEx CreateFromData(sal_uInt8 const *pData, sal_Int32 nWidth, sal_Int32 nHeight,
+                        sal_Int32 nStride, sal_Int8 nBitCount,
+                        bool bReversColors, bool bReverseAlpha)
+{
+    assert(nStride >= (nWidth * nBitCount / 8));
+    assert(nBitCount == 1 || nBitCount == 8 || nBitCount == 24 || nBitCount == 32);
+
+    PixelFormat ePixelFormat;
+    if (nBitCount == 1)
+        ePixelFormat = PixelFormat::N8_BPP; // we convert 1-bit input data to 8-bit format
+    else if (nBitCount == 8)
+        ePixelFormat = PixelFormat::N8_BPP;
+    else if (nBitCount == 24)
+        ePixelFormat = PixelFormat::N24_BPP;
+    else if (nBitCount == 32)
+        ePixelFormat = PixelFormat::N32_BPP;
+    else
+        std::abort();
+    Bitmap aBmp;
+    if (nBitCount == 1)
+    {
+        BitmapPalette aBiLevelPalette { COL_BLACK, COL_WHITE };
+        aBmp = Bitmap(Size(nWidth, nHeight), PixelFormat::N8_BPP, &aBiLevelPalette);
+    }
+    else
+        aBmp = Bitmap(Size(nWidth, nHeight), ePixelFormat);
+
+    BitmapScopedWriteAccess pWrite(aBmp);
+    assert(pWrite.get());
+    if( !pWrite )
+        return BitmapEx();
+    std::optional<AlphaMask> pAlphaMask;
+    BitmapScopedWriteAccess xMaskAcc;
+    if (nBitCount == 32)
+    {
+        pAlphaMask.emplace( Size(nWidth, nHeight) );
+        xMaskAcc = *pAlphaMask;
+    }
+    if (nBitCount == 1)
+    {
+        for( tools::Long y = 0; y < nHeight; ++y )
+        {
+            sal_uInt8 const *p = pData + y * nStride / 8;
+            Scanline pScanline = pWrite->GetScanline(y);
+            for (tools::Long x = 0; x < nWidth; ++x)
+            {
+                int bitIndex = (y * nStride + x) % 8;
+
+                pWrite->SetPixelOnData(pScanline, x, BitmapColor((*p >> bitIndex) & 1));
+            }
+        }
+    }
+    else
+    {
+        for( tools::Long y = 0; y < nHeight; ++y )
+        {
+            sal_uInt8 const *p = pData + (y * nStride);
+            Scanline pScanline = pWrite->GetScanline(y);
+            for (tools::Long x = 0; x < nWidth; ++x)
+            {
+                BitmapColor col;
+                if (nBitCount == 8)
+                    col = BitmapColor( *p );
+                else if ( bReversColors )
+                    col = BitmapColor( p[2], p[1], p[0] );
+                else
+                    col = BitmapColor( p[0], p[1], p[2] );
+                pWrite->SetPixelOnData(pScanline, x, col);
+                p += nBitCount/8;
+            }
+            if (nBitCount == 32)
+            {
+                p = pData + (y * nStride) + 3;
+                Scanline pMaskScanLine = xMaskAcc->GetScanline(y);
+                for (tools::Long x = 0; x < nWidth; ++x)
+                {
+                    // FIXME this parameter is badly named
+                    const sal_uInt8 nValue = bReverseAlpha ? *p : 0xff - *p;
+                    xMaskAcc->SetPixelOnData(pMaskScanLine, x, BitmapColor(nValue));
+                    p += 4;
+                }
+            }
+        }
+    }
+    // Avoid further bitmap use with unfinished write access
+    pWrite.reset();
+    xMaskAcc.reset();
+    if (nBitCount == 32)
+        return BitmapEx(aBmp, *pAlphaMask);
+    else
+        return BitmapEx(aBmp);
+}
+
+/** Copy block of image data into the bitmap.
+    Assumes that the Bitmap has been constructed with the desired size.
+*/
+BitmapEx CreateFromData( RawBitmap&& rawBitmap )
+{
+    auto nBitCount = rawBitmap.GetBitCount();
+    assert( nBitCount == 24 || nBitCount == 32);
+
+    auto ePixelFormat = vcl::PixelFormat::INVALID;
+
+    if (nBitCount == 24)
+        ePixelFormat = vcl::PixelFormat::N24_BPP;
+    else if (nBitCount == 32)
+        ePixelFormat = vcl::PixelFormat::N32_BPP;
+
+    assert(ePixelFormat != vcl::PixelFormat::INVALID);
+
+    Bitmap aBmp(rawBitmap.maSize, ePixelFormat);
+
+    BitmapScopedWriteAccess pWrite(aBmp);
+    assert(pWrite.get());
+    if( !pWrite )
+        return BitmapEx();
+    std::optional<AlphaMask> pAlphaMask;
+    BitmapScopedWriteAccess xMaskAcc;
+    if (nBitCount == 32)
+    {
+        pAlphaMask.emplace( rawBitmap.maSize );
+        xMaskAcc = *pAlphaMask;
+    }
+
+    auto nHeight = rawBitmap.maSize.getHeight();
+    auto nWidth = rawBitmap.maSize.getWidth();
+    auto nStride = nWidth * nBitCount / 8;
+    for( tools::Long y = 0; y < nHeight; ++y )
+    {
+        sal_uInt8 const *p = rawBitmap.mpData.get() + (y * nStride);
+        Scanline pScanline = pWrite->GetScanline(y);
+        for (tools::Long x = 0; x < nWidth; ++x)
+        {
+            BitmapColor col(p[0], p[1], p[2]);
+            pWrite->SetPixelOnData(pScanline, x, col);
+            p += nBitCount/8;
+        }
+        if (nBitCount == 32)
+        {
+            p = rawBitmap.mpData.get() + (y * nStride) + 3;
+            Scanline pMaskScanLine = xMaskAcc->GetScanline(y);
+            for (tools::Long x = 0; x < nWidth; ++x)
+            {
+                xMaskAcc->SetPixelOnData(pMaskScanLine, x, BitmapColor(*p));
+                p += 4;
+            }
+        }
+    }
+
+    xMaskAcc.reset();
+    pWrite.reset();
+
+    if (nBitCount == 32)
+        return BitmapEx(aBmp, *pAlphaMask);
+    else
+        return BitmapEx(aBmp);
+}
+
+#if ENABLE_CAIRO_CANVAS
+BitmapEx* CreateFromCairoSurface(Size aSize, cairo_surface_t * pSurface)
+{
+    // FIXME: if we could teach VCL/ about cairo handles, life could
+    // be significantly better here perhaps.
+
+    cairo_surface_t *pPixels = cairo_surface_create_similar_image(pSurface,
+            CAIRO_FORMAT_ARGB32, aSize.Width(), aSize.Height());
+    cairo_t *pCairo = cairo_create( pPixels );
+    if( !pPixels || !pCairo || cairo_status(pCairo) != CAIRO_STATUS_SUCCESS )
+        return nullptr;
+
+    // suck ourselves from the X server to this buffer so then we can fiddle with
+    // Alpha to turn it into the ultra-lame vcl required format and then push it
+    // all back again later at vast expense [ urgh ]
+    cairo_set_source_surface( pCairo, pSurface, 0, 0 );
+    cairo_set_operator( pCairo, CAIRO_OPERATOR_SOURCE );
+    cairo_paint( pCairo );
+
+    Bitmap aRGB(aSize, vcl::PixelFormat::N24_BPP);
+    ::AlphaMask aMask( aSize );
+
+    BitmapScopedWriteAccess pRGBWrite(aRGB);
+    assert(pRGBWrite);
+    if (!pRGBWrite)
+        return nullptr;
+
+    BitmapScopedWriteAccess pMaskWrite(aMask);
+    assert(pMaskWrite);
+    if (!pMaskWrite)
+        return nullptr;
+
+    cairo_surface_flush(pPixels);
+    unsigned char *pSrc = cairo_image_surface_get_data( pPixels );
+    unsigned int nStride = cairo_image_surface_get_stride( pPixels );
+#if !ENABLE_WASM_STRIP_PREMULTIPLY
+    vcl::bitmap::lookup_table const & unpremultiply_table = vcl::bitmap::get_unpremultiply_table();
+#endif
+    for( tools::Long y = 0; y < aSize.Height(); y++ )
+    {
+        sal_uInt32 *pPix = reinterpret_cast<sal_uInt32 *>(pSrc + nStride * y);
+        for( tools::Long x = 0; x < aSize.Width(); x++ )
+        {
+#if defined OSL_BIGENDIAN
+            sal_uInt8 nB = (*pPix >> 24);
+            sal_uInt8 nG = (*pPix >> 16) & 0xff;
+            sal_uInt8 nR = (*pPix >> 8) & 0xff;
+            sal_uInt8 nAlpha = *pPix & 0xff;
+#else
+            sal_uInt8 nAlpha = (*pPix >> 24);
+            sal_uInt8 nR = (*pPix >> 16) & 0xff;
+            sal_uInt8 nG = (*pPix >> 8) & 0xff;
+            sal_uInt8 nB = *pPix & 0xff;
+#endif
+            if( nAlpha != 0 && nAlpha != 255 )
+            {
+                // Cairo uses pre-multiplied alpha - we do not => re-multiply
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+                nR = vcl::bitmap::unpremultiply(nAlpha, nR);
+                nG = vcl::bitmap::unpremultiply(nAlpha, nG);
+                nB = vcl::bitmap::unpremultiply(nAlpha, nB);
+#else
+                nR = unpremultiply_table[nAlpha][nR];
+                nG = unpremultiply_table[nAlpha][nG];
+                nB = unpremultiply_table[nAlpha][nB];
+#endif
+            }
+            pRGBWrite->SetPixel( y, x, BitmapColor( nR, nG, nB ) );
+            pMaskWrite->SetPixelIndex( y, x, nAlpha );
+            pPix++;
+        }
+    }
+
+    // ignore potential errors above. will get caller a
+    // uniformly white bitmap, but not that there would
+    // be error handling in calling code ...
+    ::BitmapEx *pBitmapEx = new ::BitmapEx( aRGB, aMask );
+
+    cairo_destroy( pCairo );
+    cairo_surface_destroy( pPixels );
+    return pBitmapEx;
+}
+#endif
+
+BitmapEx CanvasTransformBitmap( const BitmapEx&                 rBitmap,
+                                const ::basegfx::B2DHomMatrix&  rTransform,
+                                ::basegfx::B2DRectangle const & rDestRect,
+                                ::basegfx::B2DHomMatrix const & rLocalTransform )
+{
+    const Size aBmpSize( rBitmap.GetSizePixel() );
+    Bitmap aSrcBitmap( rBitmap.GetBitmap() );
+    Bitmap aSrcAlpha;
+
+    // differentiate mask and alpha channel (on-off
+    // vs. multi-level transparency)
+    if( rBitmap.IsAlpha() )
+    {
+        aSrcAlpha = rBitmap.GetAlphaMask().GetBitmap();
+    }
+
+    BitmapScopedReadAccess pReadAccess( aSrcBitmap );
+    BitmapScopedReadAccess pAlphaReadAccess;
+    if (rBitmap.IsAlpha())
+        pAlphaReadAccess = aSrcAlpha;
+
+    if( !pReadAccess || (!pAlphaReadAccess && rBitmap.IsAlpha()) )
+    {
+        // TODO(E2): Error handling!
+        ENSURE_OR_THROW( false,
+                          "transformBitmap(): could not access source bitmap" );
+    }
+
+    // mapping table, to translate pAlphaReadAccess' pixel
+    // values into destination alpha values (needed e.g. for
+    // paletted 1-bit masks).
+    sal_uInt8 aAlphaMap[256];
+
+    if( rBitmap.IsAlpha() )
+    {
+        // source already has alpha channel - 1:1 mapping,
+        // i.e. aAlphaMap[0]=0,...,aAlphaMap[255]=255.
+        sal_uInt8  val=0;
+        sal_uInt8* pCur=aAlphaMap;
+        sal_uInt8* const pEnd=&aAlphaMap[256];
+        while(pCur != pEnd)
+            *pCur++ = val++;
+    }
+    // else: mapping table is not used
+
+    const Size aDestBmpSize( ::basegfx::fround( rDestRect.getWidth() ),
+                             ::basegfx::fround( rDestRect.getHeight() ) );
+
+    if( aDestBmpSize.IsEmpty() )
+        return BitmapEx();
+
+    Bitmap aDstBitmap(aDestBmpSize, aSrcBitmap.getPixelFormat(), &pReadAccess->GetPalette());
+    Bitmap aDstAlpha( AlphaMask( aDestBmpSize ).GetBitmap() );
+
+    {
+        // just to be on the safe side: let the
+        // ScopedAccessors get destructed before
+        // copy-constructing the resulting bitmap. This will
+        // rule out the possibility that cached accessor data
+        // is not yet written back.
+        BitmapScopedWriteAccess pWriteAccess( aDstBitmap );
+        BitmapScopedWriteAccess pAlphaWriteAccess( aDstAlpha );
+
+
+        if( pWriteAccess.get() != nullptr &&
+            pAlphaWriteAccess.get() != nullptr &&
+            rTransform.isInvertible() )
+        {
+            // we're doing inverse mapping here, i.e. mapping
+            // points from the destination bitmap back to the
+            // source
+            ::basegfx::B2DHomMatrix aTransform( rLocalTransform );
+            aTransform.invert();
+
+            // for the time being, always read as ARGB
+            for( tools::Long y=0; y<aDestBmpSize.Height(); ++y )
+            {
+                // differentiate mask and alpha channel (on-off
+                // vs. multi-level transparency)
+                if( rBitmap.IsAlpha() )
+                {
+                    Scanline pScan = pWriteAccess->GetScanline( y );
+                    Scanline pScanAlpha = pAlphaWriteAccess->GetScanline( y );
+                    // Handling alpha and mask just the same...
+                    for( tools::Long x=0; x<aDestBmpSize.Width(); ++x )
+                    {
+                        ::basegfx::B2DPoint aPoint(x,y);
+                        aPoint *= aTransform;
+
+                        const int nSrcX( ::basegfx::fround( aPoint.getX() ) );
+                        const int nSrcY( ::basegfx::fround( aPoint.getY() ) );
+                        if( nSrcX < 0 || nSrcX >= aBmpSize.Width() ||
+                            nSrcY < 0 || nSrcY >= aBmpSize.Height() )
+                        {
+                            pAlphaWriteAccess->SetPixelOnData( pScanAlpha, x, BitmapColor(0) );
+                        }
+                        else
+                        {
+                            const sal_uInt8 cAlphaIdx = pAlphaReadAccess->GetPixelIndex( nSrcY, nSrcX );
+                            pAlphaWriteAccess->SetPixelOnData( pScanAlpha, x, BitmapColor(aAlphaMap[ cAlphaIdx ]) );
+                            pWriteAccess->SetPixelOnData( pScan, x, pReadAccess->GetPixel( nSrcY, nSrcX ) );
+                        }
+                    }
+                }
+                else
+                {
+                    Scanline pScan = pWriteAccess->GetScanline( y );
+                    Scanline pScanAlpha = pAlphaWriteAccess->GetScanline( y );
+                    for( tools::Long x=0; x<aDestBmpSize.Width(); ++x )
+                    {
+                        ::basegfx::B2DPoint aPoint(x,y);
+                        aPoint *= aTransform;
+
+                        const int nSrcX( ::basegfx::fround( aPoint.getX() ) );
+                        const int nSrcY( ::basegfx::fround( aPoint.getY() ) );
+                        if( nSrcX < 0 || nSrcX >= aBmpSize.Width() ||
+                            nSrcY < 0 || nSrcY >= aBmpSize.Height() )
+                        {
+                            pAlphaWriteAccess->SetPixelOnData( pScanAlpha, x, BitmapColor(0) );
+                        }
+                        else
+                        {
+                            pAlphaWriteAccess->SetPixelOnData( pScanAlpha, x, BitmapColor(255) );
+                            pWriteAccess->SetPixelOnData( pScan, x, pReadAccess->GetPixel( nSrcY,
+                                                                                 nSrcX ) );
+                        }
+                    }
+                }
+            }
+        }
+        else
+        {
+            // TODO(E2): Error handling!
+            ENSURE_OR_THROW( false,
+                              "transformBitmap(): could not access bitmap" );
+        }
+    }
+
+    return BitmapEx(aDstBitmap, AlphaMask(aDstAlpha));
+}
+
+
+void DrawAlphaBitmapAndAlphaGradient(BitmapEx & rBitmapEx, bool bFixedTransparence, float fTransparence, AlphaMask & rNewMask)
+{
+    // mix existing and new alpha mask
+    AlphaMask aOldMask;
+
+    if(rBitmapEx.IsAlpha())
+    {
+        aOldMask = rBitmapEx.GetAlphaMask();
+    }
+
+    {
+
+        BitmapScopedWriteAccess pOld(aOldMask);
+
+        assert(pOld && "Got no access to old alpha mask (!)");
+
+        const double fFactor(1.0 / 255.0);
+
+        if(bFixedTransparence)
+        {
+            const double fOpNew(1.0 - fTransparence);
+
+            for(tools::Long y(0); y < pOld->Height(); y++)
+            {
+                Scanline pScanline = pOld->GetScanline( y );
+                for(tools::Long x(0); x < pOld->Width(); x++)
+                {
+                    const double fOpOld(pOld->GetIndexFromData(pScanline, x) * fFactor);
+                    const sal_uInt8 aCol(basegfx::fround((fOpOld * fOpNew) * 255.0));
+
+                    pOld->SetPixelOnData(pScanline, x, BitmapColor(aCol));
+                }
+            }
+        }
+        else
+        {
+            BitmapScopedReadAccess pNew(rNewMask);
+
+            assert(pNew && "Got no access to new alpha mask (!)");
+
+            assert(pOld->Width() == pNew->Width() && pOld->Height() == pNew->Height() &&
+                    "Alpha masks have different sizes (!)");
+
+            for(tools::Long y(0); y < pOld->Height(); y++)
+            {
+                Scanline pScanline = pOld->GetScanline( y );
+                for(tools::Long x(0); x < pOld->Width(); x++)
+                {
+                    const double fOpOld(pOld->GetIndexFromData(pScanline, x) * fFactor);
+                    const double fOpNew(pNew->GetIndexFromData(pScanline, x) * fFactor);
+                    const sal_uInt8 aCol(basegfx::fround((fOpOld * fOpNew) * 255.0));
+
+                    pOld->SetPixelOnData(pScanline, x, BitmapColor(aCol));
+                }
+            }
+        }
+
+    }
+
+    // apply combined bitmap as mask
+    rBitmapEx = BitmapEx(rBitmapEx.GetBitmap(), aOldMask);
+}
+
+
+void DrawAndClipBitmap(const Point& rPos, const Size& rSize, const BitmapEx& rBitmap, BitmapEx & aBmpEx, basegfx::B2DPolyPolygon const & rClipPath)
+{
+    ScopedVclPtrInstance< VirtualDevice > pVDev;
+    MapMode aMapMode( MapUnit::Map100thMM );
+    aMapMode.SetOrigin( Point( -rPos.X(), -rPos.Y() ) );
+    const Size aOutputSizePixel( pVDev->LogicToPixel( rSize, aMapMode ) );
+    const Size aSizePixel( rBitmap.GetSizePixel() );
+    if ( aOutputSizePixel.Width() && aOutputSizePixel.Height() )
+    {
+        aMapMode.SetScaleX( Fraction( aSizePixel.Width(), aOutputSizePixel.Width() ) );
+        aMapMode.SetScaleY( Fraction( aSizePixel.Height(), aOutputSizePixel.Height() ) );
+    }
+    pVDev->SetMapMode( aMapMode );
+    pVDev->SetOutputSizePixel( aSizePixel );
+    pVDev->SetFillColor( COL_BLACK );
+    const tools::PolyPolygon aClip( rClipPath );
+    pVDev->DrawPolyPolygon( aClip );
+
+    // #i50672# Extract whole VDev content (to match size of rBitmap)
+    pVDev->EnableMapMode( false );
+    const Bitmap aVDevMask(pVDev->GetBitmap(Point(), aSizePixel));
+
+    if(aBmpEx.IsAlpha())
+    {
+        // bitmap already uses a Mask or Alpha, we need to blend that with
+        // the new masking in pVDev.
+        // need to blend in AlphaMask quality (8Bit)
+        AlphaMask fromVDev(aVDevMask);
+        AlphaMask fromBmpEx(aBmpEx.GetAlphaMask());
+        BitmapScopedReadAccess pR(fromVDev);
+        BitmapScopedWriteAccess pW(fromBmpEx);
+
+        if(pR && pW)
+        {
+            const tools::Long nWidth(std::min(pR->Width(), pW->Width()));
+            const tools::Long nHeight(std::min(pR->Height(), pW->Height()));
+
+            for(tools::Long nY(0); nY < nHeight; nY++)
+            {
+                Scanline pScanlineR = pR->GetScanline( nY );
+                Scanline pScanlineW = pW->GetScanline( nY );
+                for(tools::Long nX(0); nX < nWidth; nX++)
+                {
+                    const sal_uInt8 nIndR(pR->GetIndexFromData(pScanlineR, nX));
+                    const sal_uInt8 nIndW(pW->GetIndexFromData(pScanlineW, nX));
+
+                    // these values represent alpha (255 == no, 0 == fully transparent),
+                    // so to blend these we have to multiply
+                    const sal_uInt8 nCombined((nIndR * nIndW) >> 8);
+
+                    pW->SetPixelOnData(pScanlineW, nX, BitmapColor(nCombined));
+                }
+            }
+        }
+
+        pR.reset();
+        pW.reset();
+        aBmpEx = BitmapEx(aBmpEx.GetBitmap(), fromBmpEx);
+    }
+    else
+    {
+        // no mask yet, create and add new mask. For better quality, use Alpha,
+        // this allows the drawn mask being processed with AntiAliasing (AAed)
+        aBmpEx = BitmapEx(rBitmap.GetBitmap(), aVDevMask);
+    }
+}
+
+
+css::uno::Sequence< sal_Int8 > GetMaskDIB(BitmapEx const & aBmpEx)
+{
+    if ( aBmpEx.IsAlpha() )
+    {
+        SvMemoryStream aMem;
+        WriteDIB(aBmpEx.GetAlphaMask().GetBitmap(), aMem, false, true);
+        return css::uno::Sequence< sal_Int8 >( static_cast<sal_Int8 const *>(aMem.GetData()), aMem.Tell() );
+    }
+
+    return css::uno::Sequence< sal_Int8 >();
+}
+
+static bool readAlpha( BitmapReadAccess const * pAlphaReadAcc, tools::Long nY, const tools::Long nWidth, unsigned char* data, tools::Long nOff )
+{
+    bool bIsAlpha = false;
+    tools::Long nX;
+    int nAlpha;
+    Scanline pReadScan;
+
+    nOff += 3;
+
+    switch( pAlphaReadAcc->GetScanlineFormat() )
+    {
+        case ScanlineFormat::N8BitPal:
+            pReadScan = pAlphaReadAcc->GetScanline( nY );
+            for( nX = 0; nX < nWidth; nX++ )
+            {
+                BitmapColor const& rColor(
+                    pAlphaReadAcc->GetPaletteColor(*pReadScan));
+                pReadScan++;
+                nAlpha = data[ nOff ] = rColor.GetIndex();
+                if( nAlpha != 255 )
+                    bIsAlpha = true;
+                nOff += 4;
+            }
+            break;
+        default:
+            SAL_INFO( "canvas.cairo", "fallback to GetColor for alpha - slow, format: " << static_cast<int>(pAlphaReadAcc->GetScanlineFormat()) );
+            for( nX = 0; nX < nWidth; nX++ )
+            {
+                nAlpha = data[ nOff ] = pAlphaReadAcc->GetColor( nY, nX ).GetIndex();
+                if( nAlpha != 255 )
+                    bIsAlpha = true;
+                nOff += 4;
+            }
+    }
+
+    return bIsAlpha;
+}
+
+
+
+/**
+ * @param data will be filled with alpha data, if xBitmap is alpha/transparent image
+ * @param bHasAlpha will be set to true if resulting surface has alpha
+ **/
+void CanvasCairoExtractBitmapData( BitmapEx const & aBmpEx, Bitmap & aBitmap, unsigned char*& data, bool& bHasAlpha, tools::Long& rnWidth, tools::Long& rnHeight )
+{
+    AlphaMask aAlpha = aBmpEx.GetAlphaMask();
+
+    BitmapScopedReadAccess pBitmapReadAcc( aBitmap );
+    BitmapScopedReadAccess pAlphaReadAcc;
+    const tools::Long      nWidth = rnWidth = pBitmapReadAcc->Width();
+    const tools::Long      nHeight = rnHeight = pBitmapReadAcc->Height();
+    tools::Long nX, nY;
+    bool bIsAlpha = false;
+
+    if( aBmpEx.IsAlpha() )
+        pAlphaReadAcc = aAlpha;
+
+    data = static_cast<unsigned char*>(malloc( nWidth*nHeight*4 ));
+
+    tools::Long nOff = 0;
+    ::Color aColor;
+    unsigned int nAlpha = 255;
+
+#if !ENABLE_WASM_STRIP_PREMULTIPLY
+    vcl::bitmap::lookup_table const & premultiply_table = vcl::bitmap::get_premultiply_table();
+#endif
+    for( nY = 0; nY < nHeight; nY++ )
+    {
+        ::Scanline pReadScan;
+
+        switch( pBitmapReadAcc->GetScanlineFormat() )
+        {
+        case ScanlineFormat::N8BitPal:
+            pReadScan = pBitmapReadAcc->GetScanline( nY );
+            if( pAlphaReadAcc )
+                if( readAlpha( pAlphaReadAcc.get(), nY, nWidth, data, nOff ) )
+                    bIsAlpha = true;
+
+            for( nX = 0; nX < nWidth; nX++ )
+            {
+#ifdef OSL_BIGENDIAN
+                if( pAlphaReadAcc )
+                    nAlpha = data[ nOff++ ];
+                else
+                    nAlpha = data[ nOff++ ] = 255;
+#else
+                if( pAlphaReadAcc )
+                    nAlpha = data[ nOff + 3 ];
+                else
+                    nAlpha = data[ nOff + 3 ] = 255;
+#endif
+                aColor = pBitmapReadAcc->GetPaletteColor(*pReadScan++);
+
+#ifdef OSL_BIGENDIAN
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, aColor.GetRed());
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, aColor.GetGreen());
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, aColor.GetBlue());
+#else
+                data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetRed()];
+                data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetGreen()];
+                data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetBlue()];
+#endif
+#else
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, aColor.GetBlue());
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, aColor.GetGreen());
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, aColor.GetRed());
+#else
+                data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetBlue()];
+                data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetGreen()];
+                data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetRed()];
+#endif
+                nOff++;
+#endif
+            }
+            break;
+        case ScanlineFormat::N24BitTcBgr:
+            pReadScan = pBitmapReadAcc->GetScanline( nY );
+            if( pAlphaReadAcc )
+                if( readAlpha( pAlphaReadAcc.get(), nY, nWidth, data, nOff ) )
+                    bIsAlpha = true;
+
+            for( nX = 0; nX < nWidth; nX++ )
+            {
+#ifdef OSL_BIGENDIAN
+                if( pAlphaReadAcc )
+                    nAlpha = data[ nOff ];
+                else
+                    nAlpha = data[ nOff ] = 255;
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+                data[ nOff + 3 ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+                data[ nOff + 2 ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+                data[ nOff + 1 ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+#else
+                data[ nOff + 3 ] = premultiply_table[nAlpha][*pReadScan++];
+                data[ nOff + 2 ] = premultiply_table[nAlpha][*pReadScan++];
+                data[ nOff + 1 ] = premultiply_table[nAlpha][*pReadScan++];
+#endif
+                nOff += 4;
+#else
+                if( pAlphaReadAcc )
+                    nAlpha = data[ nOff + 3 ];
+                else
+                    nAlpha = data[ nOff + 3 ] = 255;
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+#else
+                data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
+                data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
+                data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
+#endif
+                nOff++;
+#endif
+            }
+            break;
+        case ScanlineFormat::N24BitTcRgb:
+            pReadScan = pBitmapReadAcc->GetScanline( nY );
+            if( pAlphaReadAcc )
+                if( readAlpha( pAlphaReadAcc.get(), nY, nWidth, data, nOff ) )
+                    bIsAlpha = true;
+
+            for( nX = 0; nX < nWidth; nX++ )
+            {
+#ifdef OSL_BIGENDIAN
+                if( pAlphaReadAcc )
+                    nAlpha = data[ nOff++ ];
+                else
+                    nAlpha = data[ nOff++ ] = 255;
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+#else
+                data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
+                data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
+                data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
+#endif
+#else
+                if( pAlphaReadAcc )
+                    nAlpha = data[ nOff + 3 ];
+                else
+                    nAlpha = data[ nOff + 3 ] = 255;
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, pReadScan[ 2 ]);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, pReadScan[ 1 ]);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, pReadScan[ 0 ]);
+#else
+                data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 2 ]];
+                data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 1 ]];
+                data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 0 ]];
+#endif
+                pReadScan += 3;
+                nOff++;
+#endif
+            }
+            break;
+        case ScanlineFormat::N32BitTcBgra:
+            pReadScan = pBitmapReadAcc->GetScanline( nY );
+            if( pAlphaReadAcc )
+                if( readAlpha( pAlphaReadAcc.get(), nY, nWidth, data, nOff ) )
+                    bIsAlpha = true;
+
+            for( nX = 0; nX < nWidth; nX++ )
+            {
+#ifdef OSL_BIGENDIAN
+                if( pAlphaReadAcc )
+                    nAlpha = data[ nOff++ ];
+                else
+                    nAlpha = data[ nOff++ ] = 255;
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, pReadScan[ 2 ]);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, pReadScan[ 1 ]);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, pReadScan[ 0 ]);
+#else
+                data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 2 ]];
+                data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 1 ]];
+                data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 0 ]];
+#endif
+                pReadScan += 4;
+#else
+                if( pAlphaReadAcc )
+                    nAlpha = data[ nOff + 3 ];
+                else
+                    nAlpha = data[ nOff + 3 ] = 255;
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+#else
+                data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
+                data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
+                data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
+#endif
+                pReadScan++;
+                nOff++;
+#endif
+            }
+            break;
+        case ScanlineFormat::N32BitTcRgba:
+            pReadScan = pBitmapReadAcc->GetScanline( nY );
+            if( pAlphaReadAcc )
+                if( readAlpha( pAlphaReadAcc.get(), nY, nWidth, data, nOff ) )
+                    bIsAlpha = true;
+
+            for( nX = 0; nX < nWidth; nX++ )
+            {
+#ifdef OSL_BIGENDIAN
+                if( pAlphaReadAcc )
+                    nAlpha = data[ nOff ++ ];
+                else
+                    nAlpha = data[ nOff ++ ] = 255;
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, *pReadScan++);
+#else
+                data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
+                data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
+                data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
+#endif
+                pReadScan++;
+#else
+                if( pAlphaReadAcc )
+                    nAlpha = data[ nOff + 3 ];
+                else
+                    nAlpha = data[ nOff + 3 ] = 255;
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, pReadScan[ 2 ]);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, pReadScan[ 1 ]);
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, pReadScan[ 0 ]);
+#else
+                data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 2 ]];
+                data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 1 ]];
+                data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 0 ]];
+#endif
+                pReadScan += 4;
+                nOff++;
+#endif
+            }
+            break;
+        default:
+            SAL_INFO( "canvas.cairo", "fallback to GetColor - slow, format: " << static_cast<int>(pBitmapReadAcc->GetScanlineFormat()) );
+
+            if( pAlphaReadAcc )
+                if( readAlpha( pAlphaReadAcc.get(), nY, nWidth, data, nOff ) )
+                    bIsAlpha = true;
+
+            for( nX = 0; nX < nWidth; nX++ )
+            {
+                aColor = pBitmapReadAcc->GetColor( nY, nX );
+
+                // cairo need premultiplied color values
+                // TODO(rodo) handle endianness
+#ifdef OSL_BIGENDIAN
+                if( pAlphaReadAcc )
+                    nAlpha = data[ nOff++ ];
+                else
+                    nAlpha = data[ nOff++ ] = 255;
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, aColor.GetRed());
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, aColor.GetGreen());
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, aColor.GetBlue());
+#else
+                data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetRed()];
+                data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetGreen()];
+                data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetBlue()];
+#endif
+#else
+                if( pAlphaReadAcc )
+                    nAlpha = data[ nOff + 3 ];
+                else
+                    nAlpha = data[ nOff + 3 ] = 255;
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, aColor.GetBlue());
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, aColor.GetGreen());
+                data[ nOff++ ] = vcl::bitmap::premultiply(nAlpha, aColor.GetRed());
+#else
+                data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetBlue()];
+                data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetGreen()];
+                data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetRed()];
+#endif
+                nOff ++;
+#endif
+            }
+        }
+    }
+
+    bHasAlpha = bIsAlpha;
+
+}
+
+    uno::Sequence< sal_Int8 > CanvasExtractBitmapData(BitmapEx const & rBitmapEx, const geometry::IntegerRectangle2D& rect)
+    {
+        Bitmap aBitmap( rBitmapEx.GetBitmap() );
+        Bitmap aAlpha( rBitmapEx.GetAlphaMask().GetBitmap() );
+
+        BitmapScopedReadAccess pReadAccess( aBitmap );
+        BitmapScopedReadAccess pAlphaReadAccess;
+        if (!aAlpha.IsEmpty())
+            pAlphaReadAccess = aAlpha;
+
+        assert( pReadAccess );
+
+        // TODO(F1): Support more formats.
+        const Size aBmpSize( aBitmap.GetSizePixel() );
+
+        // for the time being, always return as BGRA
+        uno::Sequence< sal_Int8 > aRes( 4*aBmpSize.Width()*aBmpSize.Height() );
+        sal_Int8* pRes = aRes.getArray();
+
+        int nCurrPos(0);
+        for( tools::Long y=rect.Y1;
+             y<aBmpSize.Height() && y<rect.Y2;
+             ++y )
+        {
+            if( pAlphaReadAccess.get() != nullptr )
+            {
+                Scanline pScanlineReadAlpha = pAlphaReadAccess->GetScanline( y );
+                for( tools::Long x=rect.X1;
+                     x<aBmpSize.Width() && x<rect.X2;
+                     ++x )
+                {
+                    pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetRed();
+                    pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetGreen();
+                    pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetBlue();
+                    pRes[ nCurrPos++ ] = 255 - pAlphaReadAccess->GetIndexFromData( pScanlineReadAlpha, x );
+                }
+            }
+            else
+            {
+                for( tools::Long x=rect.X1;
+                     x<aBmpSize.Width() && x<rect.X2;
+                     ++x )
+                {
+                    pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetRed();
+                    pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetGreen();
+                    pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetBlue();
+                    pRes[ nCurrPos++ ] = sal_uInt8(255);
+                }
+            }
+        }
+        return aRes;
+    }
+
+    BitmapEx createHistorical8x8FromArray(std::array<sal_uInt8,64> const & pArray, Color aColorPix, Color aColorBack)
+    {
+        BitmapPalette aPalette(2);
+
+        aPalette[0] = BitmapColor(aColorBack);
+        aPalette[1] = BitmapColor(aColorPix);
+
+        Bitmap aBitmap(Size(8, 8), vcl::PixelFormat::N8_BPP, &aPalette);
+        BitmapScopedWriteAccess pContent(aBitmap);
+
+        for(sal_uInt16 a(0); a < 8; a++)
+        {
+            for(sal_uInt16 b(0); b < 8; b++)
+            {
+                if(pArray[(a * 8) + b])
+                {
+                    pContent->SetPixelIndex(a, b, 1);
+                }
+                else
+                {
+                    pContent->SetPixelIndex(a, b, 0);
+                }
+            }
+        }
+
+        return BitmapEx(aBitmap);
+    }
+
+    bool isHistorical8x8(const BitmapEx& rBitmapEx, Color& o_rBack, Color& o_rFront)
+    {
+        bool bRet(false);
+
+        if(!rBitmapEx.IsAlpha())
+        {
+            Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+            if(8 == aBitmap.GetSizePixel().Width() && 8 == aBitmap.GetSizePixel().Height())
+            {
+                // Historical 1bpp images are getting really historical,
+                // even to the point that e.g. the png loader actually loads
+                // them as RGB. But the pattern code in svx relies on this
+                // assumption that any 2-color 1bpp bitmap is a pattern, and so it would
+                // get confused by RGB. Try to detect if this image is really
+                // just two colors and say it's a pattern bitmap if so.
+                BitmapScopedReadAccess access(aBitmap);
+                o_rBack = access->GetColor(0,0);
+                bool foundSecondColor = false;;
+                for(tools::Long y = 0; y < access->Height(); ++y)
+                    for(tools::Long x = 0; x < access->Width(); ++x)
+                    {
+                        if(!foundSecondColor)
+                        {
+                            if( access->GetColor(y,x) != o_rBack )
+                            {
+                                o_rFront = access->GetColor(y,x);
+                                foundSecondColor = true;
+                                // Hard to know which of the two colors is the background,
+                                // select the lighter one.
+                                if( o_rFront.GetLuminance() > o_rBack.GetLuminance())
+                                    std::swap( o_rFront, o_rBack );
+                            }
+                        }
+                        else
+                        {
+                            if( access->GetColor(y,x) != o_rBack && access->GetColor(y,x) != o_rFront)
+                                return false;
+                        }
+                    }
+                return true;
+            }
+        }
+
+        return bRet;
+    }
+
+#if ENABLE_WASM_STRIP_PREMULTIPLY
+    sal_uInt8 unpremultiply(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 (c * a + 127) / 255;
+    }
+#else
+    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;
+    }
+
+    template<int... Is> static constexpr std::array<sal_uInt8, 256> make_unpremultiply_table_row_(
+        int a, std::integer_sequence<int, Is...>)
+    {
+        return {unpremultiplyImpl(Is, a)...};
+    }
+
+    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;
+    }
+
+    template<int... Is> static constexpr std::array<sal_uInt8, 256> make_premultiply_table_row_(
+        int a, std::integer_sequence<int, Is...>)
+    {
+        return {premultiplyImpl(Is, a)...};
+    }
+
+    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;
+    }
+#endif
+
+bool convertBitmap32To24Plus8(BitmapEx const & rInput, BitmapEx & rResult)
+{
+    Bitmap aBitmap(rInput.GetBitmap());
+    if (aBitmap.getPixelFormat() != vcl::PixelFormat::N32_BPP)
+        return false;
+
+    Size aSize = aBitmap.GetSizePixel();
+    Bitmap aResultBitmap(aSize, vcl::PixelFormat::N24_BPP);
+    AlphaMask aResultAlpha(aSize);
+    {
+        BitmapScopedWriteAccess pResultBitmapAccess(aResultBitmap);
+        BitmapScopedWriteAccess pResultAlphaAccess(aResultAlpha);
+
+        BitmapScopedReadAccess pReadAccess(aBitmap);
+
+        for (tools::Long nY = 0; nY < aSize.Height(); ++nY)
+        {
+            Scanline aResultScan = pResultBitmapAccess->GetScanline(nY);
+            Scanline aResultScanAlpha = pResultAlphaAccess->GetScanline(nY);
+
+            Scanline aReadScan = pReadAccess->GetScanline(nY);
+
+            for (tools::Long nX = 0; nX < aSize.Width(); ++nX)
+            {
+                const BitmapColor aColor = pReadAccess->GetPixelFromData(aReadScan, nX);
+                BitmapColor aResultColor(aColor.GetRed(), aColor.GetGreen(), aColor.GetBlue());
+                BitmapColor aResultColorAlpha(aColor.GetAlpha(), aColor.GetAlpha(), aColor.GetAlpha());
+
+                pResultBitmapAccess->SetPixelOnData(aResultScan, nX, aResultColor);
+                pResultAlphaAccess->SetPixelOnData(aResultScanAlpha, nX, aResultColorAlpha);
+            }
+        }
+    }
+    if (rInput.IsAlpha())
+        rResult = BitmapEx(aResultBitmap, rInput.GetAlphaMask());
+    else
+        rResult = BitmapEx(aResultBitmap, aResultAlpha);
+    return true;
+}
+
+Bitmap GetDownsampledBitmap(Size const& rDstSizeTwip, Point const& rSrcPt, Size const& rSrcSz,
+                            Bitmap const& rBmp, tools::Long nMaxBmpDPIX, tools::Long nMaxBmpDPIY)
+{
+    Bitmap aBmp(rBmp);
+
+    if (!aBmp.IsEmpty())
+    {
+        const tools::Rectangle aBmpRect( Point(), aBmp.GetSizePixel() );
+        tools::Rectangle       aSrcRect( rSrcPt, rSrcSz );
+
+        // do cropping if necessary
+        if( aSrcRect.Intersection( aBmpRect ) != aBmpRect )
+        {
+            if( !aSrcRect.IsEmpty() )
+                aBmp.Crop( aSrcRect );
+            else
+                aBmp.SetEmpty();
+        }
+
+        if( !aBmp.IsEmpty() )
+        {
+            // do downsampling if necessary
+            // #103209# Normalize size (mirroring has to happen outside of this method)
+            Size aDstSizeTwip(std::abs(rDstSizeTwip.Width()), std::abs(rDstSizeTwip.Height()));
+
+            const Size aBmpSize( aBmp.GetSizePixel() );
+            const double fBmpPixelX = aBmpSize.Width();
+            const double fBmpPixelY = aBmpSize.Height();
+            const double fMaxPixelX
+                = o3tl::convert<double>(aDstSizeTwip.Width(), o3tl::Length::twip, o3tl::Length::in)
+                  * nMaxBmpDPIX;
+            const double fMaxPixelY
+                = o3tl::convert<double>(aDstSizeTwip.Height(), o3tl::Length::twip, o3tl::Length::in)
+                  * nMaxBmpDPIY;
+
+            // check, if the bitmap DPI exceeds the maximum DPI (allow 4 pixel rounding tolerance)
+            if (((fBmpPixelX > (fMaxPixelX + 4)) ||
+                  (fBmpPixelY > (fMaxPixelY + 4))) &&
+                (fBmpPixelY > 0.0) && (fMaxPixelY > 0.0))
+            {
+                // do scaling
+                Size aNewBmpSize;
+                const double fBmpWH = fBmpPixelX / fBmpPixelY;
+                const double fMaxWH = fMaxPixelX / fMaxPixelY;
+
+                if (fBmpWH < fMaxWH)
+                {
+                    aNewBmpSize.setWidth(FRound(fMaxPixelY * fBmpWH));
+                    aNewBmpSize.setHeight(FRound(fMaxPixelY));
+                }
+                else if (fBmpWH > 0.0)
+                {
+                    aNewBmpSize.setWidth(FRound(fMaxPixelX));
+                    aNewBmpSize.setHeight(FRound(fMaxPixelX / fBmpWH));
+                }
+
+                if( aNewBmpSize.Width() && aNewBmpSize.Height() )
+                    aBmp.Scale(aNewBmpSize);
+                else
+                    aBmp.SetEmpty();
+            }
+        }
+    }
+
+    return aBmp;
+}
+
+} // end vcl::bitmap
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapWriteAccess.cxx b/vcl/source/bitmap/BitmapWriteAccess.cxx
new file mode 100644
index 0000000000..610cb2cc26
--- /dev/null
+++ b/vcl/source/bitmap/BitmapWriteAccess.cxx
@@ -0,0 +1,399 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+#include <sal/log.hxx>
+#include <tools/debug.hxx>
+
+#include <vcl/BitmapWriteAccess.hxx>
+#include <bitmap/bmpfast.hxx>
+
+BitmapWriteAccess::BitmapWriteAccess(Bitmap& rBitmap)
+    : BitmapReadAccess(rBitmap, BitmapAccessMode::Write)
+{
+}
+
+BitmapWriteAccess::BitmapWriteAccess(AlphaMask& rBitmap)
+    : BitmapReadAccess(rBitmap, BitmapAccessMode::Write)
+{
+}
+
+BitmapWriteAccess::~BitmapWriteAccess() {}
+
+void BitmapWriteAccess::CopyScanline(tools::Long nY, const BitmapReadAccess& rReadAcc)
+{
+    assert(nY >= 0 && nY < mpBuffer->mnHeight && "y-coordinate in destination out of range!");
+    SAL_WARN_IF(nY >= rReadAcc.Height(), "vcl", "y-coordinate in source out of range!");
+    SAL_WARN_IF((!HasPalette() || !rReadAcc.HasPalette())
+                    && (HasPalette() || rReadAcc.HasPalette()),
+                "vcl", "No copying possible between palette bitmap and TC bitmap!");
+
+    if ((GetScanlineFormat() == rReadAcc.GetScanlineFormat())
+        && (GetScanlineSize() >= rReadAcc.GetScanlineSize()))
+    {
+        memcpy(GetScanline(nY), rReadAcc.GetScanline(nY), rReadAcc.GetScanlineSize());
+    }
+    else
+    {
+        tools::Long nWidth = std::min(mpBuffer->mnWidth, rReadAcc.Width());
+        if (!ImplFastCopyScanline(nY, *ImplGetBitmapBuffer(), *rReadAcc.ImplGetBitmapBuffer()))
+        {
+            Scanline pScanline = GetScanline(nY);
+            Scanline pScanlineRead = rReadAcc.GetScanline(nY);
+            for (tools::Long nX = 0; nX < nWidth; nX++)
+                SetPixelOnData(pScanline, nX, rReadAcc.GetPixelFromData(pScanlineRead, nX));
+        }
+    }
+}
+
+void BitmapWriteAccess::CopyScanline(tools::Long nY, ConstScanline aSrcScanline,
+                                     ScanlineFormat nSrcScanlineFormat, sal_uInt32 nSrcScanlineSize)
+{
+    const ScanlineFormat nFormat = RemoveScanline(nSrcScanlineFormat);
+
+    assert(nY >= 0 && nY < mpBuffer->mnHeight && "y-coordinate in destination out of range!");
+    DBG_ASSERT((HasPalette() && nFormat <= ScanlineFormat::N8BitPal)
+                   || (!HasPalette() && nFormat > ScanlineFormat::N8BitPal),
+               "No copying possible between palette and non palette scanlines!");
+
+    const sal_uInt32 nCount = std::min(GetScanlineSize(), nSrcScanlineSize);
+
+    if (!nCount)
+        return;
+
+    if (GetScanlineFormat() == RemoveScanline(nSrcScanlineFormat))
+        memcpy(GetScanline(nY), aSrcScanline, nCount);
+    else
+    {
+        if (ImplFastCopyScanline(nY, *ImplGetBitmapBuffer(), aSrcScanline, nSrcScanlineFormat,
+                                 nSrcScanlineSize))
+            return;
+
+        DBG_ASSERT(nFormat != ScanlineFormat::N32BitTcMask,
+                   "No support for pixel formats with color masks yet!");
+        FncGetPixel pFncGetPixel;
+        switch (nFormat)
+        {
+            case ScanlineFormat::N1BitMsbPal:
+                pFncGetPixel = GetPixelForN1BitMsbPal;
+                break;
+            case ScanlineFormat::N8BitPal:
+                pFncGetPixel = GetPixelForN8BitPal;
+                break;
+            case ScanlineFormat::N24BitTcBgr:
+                pFncGetPixel = GetPixelForN24BitTcBgr;
+                break;
+            case ScanlineFormat::N24BitTcRgb:
+                pFncGetPixel = GetPixelForN24BitTcRgb;
+                break;
+            case ScanlineFormat::N32BitTcAbgr:
+                if (Bitmap32IsPreMultipled())
+                    pFncGetPixel = GetPixelForN32BitTcAbgr;
+                else
+                    pFncGetPixel = GetPixelForN32BitTcXbgr;
+                break;
+            case ScanlineFormat::N32BitTcArgb:
+                if (Bitmap32IsPreMultipled())
+                    pFncGetPixel = GetPixelForN32BitTcArgb;
+                else
+                    pFncGetPixel = GetPixelForN32BitTcXrgb;
+                break;
+            case ScanlineFormat::N32BitTcBgra:
+                if (Bitmap32IsPreMultipled())
+                    pFncGetPixel = GetPixelForN32BitTcBgra;
+                else
+                    pFncGetPixel = GetPixelForN32BitTcBgrx;
+                break;
+            case ScanlineFormat::N32BitTcRgba:
+                if (Bitmap32IsPreMultipled())
+                    pFncGetPixel = GetPixelForN32BitTcRgba;
+                else
+                    pFncGetPixel = GetPixelForN32BitTcRgbx;
+                break;
+            case ScanlineFormat::N32BitTcMask:
+                pFncGetPixel = GetPixelForN32BitTcMask;
+                break;
+
+            default:
+                assert(false);
+                pFncGetPixel = nullptr;
+                break;
+        }
+
+        if (pFncGetPixel)
+        {
+            const ColorMask aDummyMask;
+            Scanline pScanline = GetScanline(nY);
+            for (tools::Long nX = 0, nWidth = mpBuffer->mnWidth; nX < nWidth; ++nX)
+                SetPixelOnData(pScanline, nX, pFncGetPixel(aSrcScanline, nX, aDummyMask));
+        }
+    }
+}
+
+void BitmapWriteAccess::SetLineColor(const Color& rColor)
+{
+    if (rColor.GetAlpha() == 0)
+    {
+        mpLineColor.reset();
+    }
+    else
+    {
+        if (HasPalette())
+        {
+            mpLineColor = BitmapColor(static_cast<sal_uInt8>(GetBestPaletteIndex(rColor)));
+        }
+        else
+        {
+            mpLineColor = BitmapColor(rColor);
+        }
+    }
+}
+
+void BitmapWriteAccess::SetFillColor() { mpFillColor.reset(); }
+
+void BitmapWriteAccess::SetFillColor(const Color& rColor)
+{
+    if (rColor.GetAlpha() == 0)
+    {
+        mpFillColor.reset();
+    }
+    else
+    {
+        if (HasPalette())
+        {
+            mpFillColor = BitmapColor(static_cast<sal_uInt8>(GetBestPaletteIndex(rColor)));
+        }
+        else
+        {
+            mpFillColor = BitmapColor(rColor);
+        }
+    }
+}
+
+void BitmapWriteAccess::Erase(const Color& rColor)
+{
+    // convert the color format from RGB to palette index if needed
+    // TODO: provide and use Erase( BitmapColor& method)
+    BitmapColor aColor = rColor;
+    if (HasPalette())
+    {
+        aColor = BitmapColor(static_cast<sal_uInt8>(GetBestPaletteIndex(rColor)));
+    }
+
+    // try fast bitmap method first
+    if (ImplFastEraseBitmap(*mpBuffer, aColor))
+        return;
+
+    tools::Rectangle aRect(Point(), maBitmap.GetSizePixel());
+    if (aRect.IsEmpty())
+        return;
+    // clear the bitmap by filling the first line pixel by pixel,
+    // then dup the first line over each other line
+    Scanline pFirstScanline = GetScanline(0);
+    const tools::Long nEndX = aRect.Right();
+    for (tools::Long nX = 0; nX <= nEndX; ++nX)
+        SetPixelOnData(pFirstScanline, nX, rColor);
+    const auto nScanlineSize = GetScanlineSize();
+    const tools::Long nEndY = aRect.Bottom();
+    for (tools::Long nY = 1; nY <= nEndY; nY++)
+    {
+        Scanline pDestScanline = GetScanline(nY);
+        memcpy(pDestScanline, pFirstScanline, nScanlineSize);
+    }
+}
+
+void BitmapWriteAccess::DrawLine(const Point& rStart, const Point& rEnd)
+{
+    if (!mpLineColor)
+        return;
+
+    const BitmapColor& rLineColor = *mpLineColor;
+    tools::Long nX, nY;
+
+    if (rStart.X() == rEnd.X())
+    {
+        // Vertical Line
+        const tools::Long nEndY = rEnd.Y();
+
+        nX = rStart.X();
+        nY = rStart.Y();
+
+        if (nEndY > nY)
+        {
+            for (; nY <= nEndY; nY++)
+                SetPixel(nY, nX, rLineColor);
+        }
+        else
+        {
+            for (; nY >= nEndY; nY--)
+                SetPixel(nY, nX, rLineColor);
+        }
+    }
+    else if (rStart.Y() == rEnd.Y())
+    {
+        // Horizontal Line
+        const tools::Long nEndX = rEnd.X();
+
+        nX = rStart.X();
+        nY = rStart.Y();
+
+        if (nEndX > nX)
+        {
+            for (; nX <= nEndX; nX++)
+                SetPixel(nY, nX, rLineColor);
+        }
+        else
+        {
+            for (; nX >= nEndX; nX--)
+                SetPixel(nY, nX, rLineColor);
+        }
+    }
+    else
+    {
+        const tools::Long nDX = std::abs(rEnd.X() - rStart.X());
+        const tools::Long nDY = std::abs(rEnd.Y() - rStart.Y());
+        tools::Long nX1;
+        tools::Long nY1;
+        tools::Long nX2;
+        tools::Long nY2;
+
+        if (nDX >= nDY)
+        {
+            if (rStart.X() < rEnd.X())
+            {
+                nX1 = rStart.X();
+                nY1 = rStart.Y();
+                nX2 = rEnd.X();
+                nY2 = rEnd.Y();
+            }
+            else
+            {
+                nX1 = rEnd.X();
+                nY1 = rEnd.Y();
+                nX2 = rStart.X();
+                nY2 = rStart.Y();
+            }
+
+            const tools::Long nDYX = (nDY - nDX) << 1;
+            const tools::Long nDY2 = nDY << 1;
+            tools::Long nD = nDY2 - nDX;
+            bool bPos = nY1 < nY2;
+
+            for (nX = nX1, nY = nY1; nX <= nX2; nX++)
+            {
+                SetPixel(nY, nX, rLineColor);
+
+                if (nD < 0)
+                    nD += nDY2;
+                else
+                {
+                    nD += nDYX;
+
+                    if (bPos)
+                        nY++;
+                    else
+                        nY--;
+                }
+            }
+        }
+        else
+        {
+            if (rStart.Y() < rEnd.Y())
+            {
+                nX1 = rStart.X();
+                nY1 = rStart.Y();
+                nX2 = rEnd.X();
+                nY2 = rEnd.Y();
+            }
+            else
+            {
+                nX1 = rEnd.X();
+                nY1 = rEnd.Y();
+                nX2 = rStart.X();
+                nY2 = rStart.Y();
+            }
+
+            const tools::Long nDYX = (nDX - nDY) << 1;
+            const tools::Long nDY2 = nDX << 1;
+            tools::Long nD = nDY2 - nDY;
+            bool bPos = nX1 < nX2;
+
+            for (nX = nX1, nY = nY1; nY <= nY2; nY++)
+            {
+                SetPixel(nY, nX, rLineColor);
+
+                if (nD < 0)
+                    nD += nDY2;
+                else
+                {
+                    nD += nDYX;
+
+                    if (bPos)
+                        nX++;
+                    else
+                        nX--;
+                }
+            }
+        }
+    }
+}
+
+void BitmapWriteAccess::FillRect(const tools::Rectangle& rRect)
+{
+    if (!mpFillColor)
+        return;
+
+    const BitmapColor& rFillColor = *mpFillColor;
+    tools::Rectangle aRect(Point(), maBitmap.GetSizePixel());
+
+    aRect.Intersection(rRect);
+
+    if (aRect.IsEmpty())
+        return;
+
+    const tools::Long nStartX = rRect.Left();
+    const tools::Long nStartY = rRect.Top();
+    const tools::Long nEndX = rRect.Right();
+    const tools::Long nEndY = rRect.Bottom();
+
+    for (tools::Long nY = nStartY; nY <= nEndY; nY++)
+    {
+        Scanline pScanline = GetScanline(nY);
+        for (tools::Long nX = nStartX; nX <= nEndX; nX++)
+        {
+            SetPixelOnData(pScanline, nX, rFillColor);
+        }
+    }
+}
+
+void BitmapWriteAccess::DrawRect(const tools::Rectangle& rRect)
+{
+    if (mpFillColor)
+        FillRect(rRect);
+
+    if (mpLineColor && (!mpFillColor || (*mpFillColor != *mpLineColor)))
+    {
+        DrawLine(rRect.TopLeft(), rRect.TopRight());
+        DrawLine(rRect.TopRight(), rRect.BottomRight());
+        DrawLine(rRect.BottomRight(), rRect.BottomLeft());
+        DrawLine(rRect.BottomLeft(), rRect.TopLeft());
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/Octree.cxx b/vcl/source/bitmap/Octree.cxx
new file mode 100644
index 0000000000..98ad8c9fcf
--- /dev/null
+++ b/vcl/source/bitmap/Octree.cxx
@@ -0,0 +1,280 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <vcl/BitmapReadAccess.hxx>
+
+#include <bitmap/Octree.hxx>
+
+namespace
+{
+constexpr size_t OCTREE_BITS = 5;
+constexpr size_t OCTREE_BITS_1 = 10;
+
+constexpr sal_uLong gnBits = 8 - OCTREE_BITS;
+
+} // end anonymous namespace
+
+Octree::Octree(const BitmapReadAccess& rReadAcc, sal_uLong nColors)
+    : mnLeafCount(0)
+    , mnLevel(0)
+    , mpReduce(OCTREE_BITS + 1, nullptr)
+    , mnPalIndex(0)
+{
+    const BitmapReadAccess* pAccess = &rReadAcc;
+    sal_uLong nMax(nColors);
+
+    if (!*pAccess)
+        return;
+
+    const tools::Long nWidth = pAccess->Width();
+    const tools::Long nHeight = pAccess->Height();
+
+    if (pAccess->HasPalette())
+    {
+        for (tools::Long nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pAccess->GetScanline(nY);
+            for (tools::Long nX = 0; nX < nWidth; nX++)
+            {
+                mnLevel = 0;
+                add(pTree, pAccess->GetPaletteColor(pAccess->GetIndexFromData(pScanline, nX)));
+
+                while (mnLeafCount > nMax)
+                    reduce();
+            }
+        }
+    }
+    else
+    {
+        for (tools::Long nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pAccess->GetScanline(nY);
+            for (tools::Long nX = 0; nX < nWidth; nX++)
+            {
+                mnLevel = 0;
+                add(pTree, pAccess->GetPixelFromData(pScanline, nX));
+
+                while (mnLeafCount > nMax)
+                    reduce();
+            }
+        }
+    }
+}
+
+Octree::~Octree() {}
+
+void Octree::add(std::unique_ptr<OctreeNode>& rpNode, BitmapColor const& color)
+{
+    // possibly generate new nodes
+    if (!rpNode)
+    {
+        rpNode.reset(new OctreeNode);
+        rpNode->bLeaf = (OCTREE_BITS == mnLevel);
+
+        if (rpNode->bLeaf)
+            mnLeafCount++;
+        else
+        {
+            rpNode->pNext = mpReduce[mnLevel];
+            mpReduce[mnLevel] = rpNode.get();
+        }
+    }
+
+    if (rpNode->bLeaf)
+    {
+        rpNode->nCount++;
+        rpNode->nRed += color.GetRed();
+        rpNode->nGreen += color.GetGreen();
+        rpNode->nBlue += color.GetBlue();
+    }
+    else
+    {
+        const sal_uLong nShift = 7 - mnLevel;
+        const sal_uInt8 cMask = 0x80 >> mnLevel;
+        const sal_uLong nIndex = (((color.GetRed() & cMask) >> nShift) << 2)
+                                 | (((color.GetGreen() & cMask) >> nShift) << 1)
+                                 | ((color.GetBlue() & cMask) >> nShift);
+
+        mnLevel++;
+        add(rpNode->pChild[nIndex], color);
+    }
+}
+
+void Octree::reduce()
+{
+    OctreeNode* pNode;
+    sal_uLong nRedSum = 0;
+    sal_uLong nGreenSum = 0;
+    sal_uLong nBlueSum = 0;
+    sal_uLong nChildren = 0;
+
+    sal_uLong nIndex = OCTREE_BITS - 1;
+    while (nIndex > 0 && !mpReduce[nIndex])
+    {
+        nIndex--;
+    }
+
+    pNode = mpReduce[nIndex];
+    mpReduce[nIndex] = pNode->pNext;
+
+    for (unsigned int i = 0; i < 8; i++)
+    {
+        if (pNode->pChild[i])
+        {
+            OctreeNode* pChild = pNode->pChild[i].get();
+
+            nRedSum += pChild->nRed;
+            nGreenSum += pChild->nGreen;
+            nBlueSum += pChild->nBlue;
+            pNode->nCount += pChild->nCount;
+
+            pNode->pChild[i].reset();
+            nChildren++;
+        }
+    }
+
+    pNode->bLeaf = true;
+    pNode->nRed = nRedSum;
+    pNode->nGreen = nGreenSum;
+    pNode->nBlue = nBlueSum;
+    mnLeafCount -= --nChildren;
+}
+
+void Octree::CreatePalette(OctreeNode* pNode)
+{
+    if (pNode->bLeaf)
+    {
+        pNode->nPalIndex = mnPalIndex;
+        maPalette[mnPalIndex++] = BitmapColor(sal_uInt8(double(pNode->nRed) / pNode->nCount),
+                                              sal_uInt8(double(pNode->nGreen) / pNode->nCount),
+                                              sal_uInt8(double(pNode->nBlue) / pNode->nCount));
+    }
+    else
+    {
+        for (auto const& i : pNode->pChild)
+        {
+            if (i)
+            {
+                CreatePalette(i.get());
+            }
+        }
+    }
+}
+
+void Octree::GetPalIndex(const OctreeNode* pNode, BitmapColor const& color)
+{
+    if (pNode->bLeaf)
+        mnPalIndex = pNode->nPalIndex;
+    else
+    {
+        const sal_uLong nShift = 7 - mnLevel;
+        const sal_uInt8 cMask = 0x80 >> mnLevel;
+        mnLevel++;
+        const sal_uLong nIndex = (((color.GetRed() & cMask) >> nShift) << 2)
+                                 | (((color.GetGreen() & cMask) >> nShift) << 1)
+                                 | ((color.GetBlue() & cMask) >> nShift);
+
+        GetPalIndex(pNode->pChild[nIndex].get(), color);
+    }
+}
+
+const BitmapPalette& Octree::GetPalette()
+{
+    maPalette.SetEntryCount(sal_uInt16(mnLeafCount));
+    mnPalIndex = 0;
+    CreatePalette(pTree.get());
+    return maPalette;
+}
+
+sal_uInt16 Octree::GetBestPaletteIndex(const BitmapColor& rColor)
+{
+    mnPalIndex = 65535;
+    mnLevel = 0;
+    GetPalIndex(pTree.get(), rColor);
+    return mnPalIndex;
+}
+
+constexpr int nColorMax = 1 << OCTREE_BITS;
+
+InverseColorMap::InverseColorMap(const BitmapPalette& rPal)
+{
+    const unsigned long xsqr = 1 << (gnBits << 1);
+    const unsigned long xsqr2 = xsqr << 1;
+    const int nColors = rPal.GetEntryCount();
+    const tools::Long x = 1 << gnBits;
+    const tools::Long x2 = x >> 1;
+    sal_uLong r, g, b;
+    tools::Long rxx, gxx, bxx;
+
+    ImplCreateBuffers();
+
+    for (int nIndex = 0; nIndex < nColors; nIndex++)
+    {
+        const BitmapColor& rColor = rPal[static_cast<sal_uInt16>(nIndex)];
+        const tools::Long cRed = rColor.GetRed();
+        const tools::Long cGreen = rColor.GetGreen();
+        const tools::Long cBlue = rColor.GetBlue();
+
+        tools::Long rdist = cRed - x2;
+        tools::Long gdist = cGreen - x2;
+        tools::Long bdist = cBlue - x2;
+        rdist = rdist * rdist + gdist * gdist + bdist * bdist;
+
+        const tools::Long crinc = (xsqr - (cRed << gnBits)) << 1;
+        const tools::Long cginc = (xsqr - (cGreen << gnBits)) << 1;
+        const tools::Long cbinc = (xsqr - (cBlue << gnBits)) << 1;
+
+        sal_uLong* cdp = reinterpret_cast<sal_uLong*>(mpBuffer.data());
+        sal_uInt8* crgbp = mpMap.data();
+
+        for (r = 0, rxx = crinc; r < nColorMax; rdist += rxx, r++, rxx += xsqr2)
+        {
+            for (g = 0, gdist = rdist, gxx = cginc; g < nColorMax; gdist += gxx, g++, gxx += xsqr2)
+            {
+                for (b = 0, bdist = gdist, bxx = cbinc; b < nColorMax;
+                     bdist += bxx, b++, cdp++, crgbp++, bxx += xsqr2)
+                    if (!nIndex || static_cast<tools::Long>(*cdp) > bdist)
+                    {
+                        *cdp = bdist;
+                        *crgbp = static_cast<sal_uInt8>(nIndex);
+                    }
+            }
+        }
+    }
+}
+
+InverseColorMap::~InverseColorMap() {}
+
+void InverseColorMap::ImplCreateBuffers()
+{
+    const sal_uLong nCount = nColorMax * nColorMax * nColorMax;
+    const sal_uLong nSize = nCount * sizeof(sal_uLong);
+
+    mpMap.resize(nCount, 0x00);
+    mpBuffer.resize(nSize, 0xff);
+}
+
+sal_uInt16 InverseColorMap::GetBestPaletteIndex(const BitmapColor& rColor)
+{
+    return mpMap[((static_cast<sal_uLong>(rColor.GetRed()) >> gnBits) << OCTREE_BITS_1)
+                 | ((static_cast<sal_uLong>(rColor.GetGreen()) >> gnBits) << OCTREE_BITS)
+                 | (static_cast<sal_uLong>(rColor.GetBlue()) >> gnBits)];
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/alpha.cxx b/vcl/source/bitmap/alpha.cxx
new file mode 100644
index 0000000000..634fc3cdd6
--- /dev/null
+++ b/vcl/source/bitmap/alpha.cxx
@@ -0,0 +1,209 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <tools/color.hxx>
+#include <vcl/alpha.hxx>
+
+#include <vcl/BitmapWriteAccess.hxx>
+#include <salinst.hxx>
+#include <svdata.hxx>
+#include <salbmp.hxx>
+#include <sal/log.hxx>
+#if HAVE_FEATURE_SKIA
+#include <vcl/skia/SkiaHelper.hxx>
+#endif
+
+
+AlphaMask::AlphaMask() = default;
+
+AlphaMask::AlphaMask( const Bitmap& rBitmap ) :
+    maBitmap( rBitmap )
+{
+    if ( !rBitmap.IsEmpty() )
+        maBitmap.Convert( BmpConversion::N8BitNoConversion );
+#if HAVE_FEATURE_SKIA
+    // Related tdf#156866 force snapshot of alpha mask when using Skia
+    // In release builds, tdf#156629 and tdf#156630 reappear in many
+    // cases because a BitmapInfoAccess is in a debug block. So, instead
+    // of relying on other code to a create a BitmapInfoAccess instance,
+    // create one here to force the alpha mask to handle any pending
+    // scaling and make the alpha mask immutable.
+    else if ( SkiaHelper::isVCLSkiaEnabled() )
+        BitmapInfoAccess aInfoAccess( maBitmap );
+#endif
+    assert( (IsEmpty() || maBitmap.getPixelFormat() == vcl::PixelFormat::N8_BPP) && "alpha bitmap should be 8bpp" );
+    assert( (IsEmpty() || maBitmap.HasGreyPalette8Bit()) && "alpha bitmap should have greyscale palette" );
+}
+
+AlphaMask::AlphaMask( const AlphaMask& ) = default;
+
+AlphaMask::AlphaMask( AlphaMask&& ) = default;
+
+AlphaMask::AlphaMask( const Size& rSizePixel, const sal_uInt8* pEraseTransparency )
+    : maBitmap(rSizePixel, vcl::PixelFormat::N8_BPP, &Bitmap::GetGreyPalette(256))
+{
+    if( pEraseTransparency )
+    {
+        sal_uInt8 nAlpha = 255 - *pEraseTransparency;
+        maBitmap.Erase( Color( nAlpha, nAlpha, nAlpha ) );
+    }
+    else
+        maBitmap.Erase( COL_ALPHA_OPAQUE );
+}
+
+AlphaMask::~AlphaMask() = default;
+
+AlphaMask& AlphaMask::operator=( const Bitmap& rBitmap )
+{
+    maBitmap = rBitmap;
+
+    if( !rBitmap.IsEmpty() )
+        maBitmap.Convert( BmpConversion::N8BitNoConversion );
+
+    assert( maBitmap.getPixelFormat() == vcl::PixelFormat::N8_BPP && "alpha bitmap should be 8bpp" );
+    assert( maBitmap.HasGreyPalette8Bit() && "alpha bitmap should have greyscale palette" );
+
+    return *this;
+}
+
+void AlphaMask::Erase( sal_uInt8 cTransparency )
+{
+    sal_uInt8 nAlpha = 255 - cTransparency;
+    maBitmap.Erase( Color( nAlpha, nAlpha, nAlpha ) );
+}
+
+void AlphaMask::BlendWith(const AlphaMask& rOther)
+{
+    std::shared_ptr<SalBitmap> xImpBmp(ImplGetSVData()->mpDefInst->CreateSalBitmap());
+    if (xImpBmp->Create(*maBitmap.ImplGetSalBitmap()) && xImpBmp->AlphaBlendWith(*rOther.maBitmap.ImplGetSalBitmap()))
+    {
+        maBitmap.ImplSetSalBitmap(xImpBmp);
+        assert( maBitmap.getPixelFormat() == vcl::PixelFormat::N8_BPP && "alpha bitmap should be 8bpp" );
+        assert( maBitmap.HasGreyPalette8Bit() && "alpha bitmap should have greyscale palette" );
+        return;
+    }
+    BitmapScopedReadAccess pOtherAcc(rOther);
+    BitmapScopedWriteAccess pAcc(*this);
+    assert (pOtherAcc && pAcc && pOtherAcc->GetBitCount() == 8 && pAcc->GetBitCount() == 8 && "cannot BlendWith this combination");
+    if (!(pOtherAcc && pAcc && pOtherAcc->GetBitCount() == 8 && pAcc->GetBitCount() == 8))
+    {
+        SAL_WARN("vcl", "cannot BlendWith this combination");
+        return;
+    }
+
+    const tools::Long nHeight = std::min(pOtherAcc->Height(), pAcc->Height());
+    const tools::Long nWidth = std::min(pOtherAcc->Width(), pAcc->Width());
+    for (tools::Long y = 0; y < nHeight; ++y)
+    {
+        Scanline scanline = pAcc->GetScanline( y );
+        ConstScanline otherScanline = pOtherAcc->GetScanline( y );
+        for (tools::Long x = 0; x < nWidth; ++x)
+        {
+            // Use sal_uInt16 for following multiplication
+            const sal_uInt16 nGrey1 = *scanline;
+            const sal_uInt16 nGrey2 = *otherScanline;
+            // Awkward calculation because the original used transparency, and to replicate
+            // the logic we need to translate into transparency, perform the original logic,
+            // then translate back to alpha.
+            // The original looked like:
+            //   auto tmp = nGrey1 + nGrey2 - (nGrey1 * nGrey2 / 255)
+            // which, when converted to using alpha looks like
+            //   auto tmp = 255 - ((255 - nGrey1) + (255 - nGrey2) - (255 - nGrey1) * (255 - nGrey2) / 255);
+            // which then simplifies to:
+            auto tmp = nGrey1 * nGrey2 / 255;
+            *scanline = static_cast<sal_uInt8>(tmp);
+            ++scanline;
+            ++otherScanline;
+        }
+    }
+    pAcc.reset();
+    assert( maBitmap.getPixelFormat() == vcl::PixelFormat::N8_BPP && "alpha bitmap should be 8bpp" );
+    assert( maBitmap.HasGreyPalette8Bit() && "alpha bitmap should have greyscale palette" );
+}
+
+bool AlphaMask::hasAlpha() const
+{
+    // no content, no alpha
+    if(IsEmpty())
+        return false;
+
+    BitmapScopedReadAccess pAcc(*this);
+    const tools::Long nHeight(pAcc->Height());
+    const tools::Long nWidth(pAcc->Width());
+
+    // no content, no alpha
+    if(0 == nHeight || 0 == nWidth)
+        return false;
+
+    for (tools::Long y = 0; y < nHeight; ++y)
+    {
+        for (tools::Long x = 0; x < nWidth; ++x)
+        {
+            if (255 != pAcc->GetColor(y, x).GetRed())
+            {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+bool AlphaMask::AlphaCombineOr(const AlphaMask& rMask)
+{
+    BitmapScopedReadAccess pMaskAcc(rMask);
+    BitmapScopedWriteAccess pAcc(*this);
+
+    if (!pMaskAcc || !pAcc)
+        return false;
+
+    assert (pMaskAcc->GetBitCount() == 8 && pAcc->GetBitCount() == 8);
+
+    const tools::Long nWidth = std::min(pMaskAcc->Width(), pAcc->Width());
+    const tools::Long nHeight = std::min(pMaskAcc->Height(), pAcc->Height());
+
+    for (tools::Long nY = 0; nY < nHeight; nY++)
+    {
+        Scanline pScanline = pAcc->GetScanline(nY);
+        ConstScanline pScanlineMask = pMaskAcc->GetScanline(nY);
+        for (tools::Long nX = 0; nX < nWidth; nX++)
+        {
+            if (*pScanlineMask != 255 || *pScanline != 255)
+                *pScanline = 0;
+            else
+                *pScanline = 255;
+            ++pScanline;
+            ++pScanlineMask;
+        }
+    }
+
+    return true;
+}
+
+bool AlphaMask::Invert()
+{
+    if (IsEmpty())
+        return false;
+    bool b = maBitmap.Invert();
+    assert( maBitmap.getPixelFormat() == vcl::PixelFormat::N8_BPP && "alpha bitmap should be 8bpp" );
+    assert( maBitmap.HasGreyPalette8Bit() && "alpha bitmap should have greyscale palette" );
+    return b;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/bitmap.cxx b/vcl/source/bitmap/bitmap.cxx
new file mode 100644
index 0000000000..53b30d0b31
--- /dev/null
+++ b/vcl/source/bitmap/bitmap.cxx
@@ -0,0 +1,1681 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <config_features.h>
+
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+#include <tools/helpers.hxx>
+
+#include <utility>
+#include <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/outdev.hxx>
+
+#include <svdata.hxx>
+#include <salinst.hxx>
+#include <salbmp.hxx>
+#if HAVE_FEATURE_SKIA
+#include <vcl/skia/SkiaHelper.hxx>
+#endif
+#include <vcl/BitmapMonochromeFilter.hxx>
+
+#include <bitmap/BitmapScaleSuperFilter.hxx>
+#include <bitmap/BitmapScaleConvolutionFilter.hxx>
+#include <bitmap/BitmapFastScaleFilter.hxx>
+#include <bitmap/BitmapInterpolateScaleFilter.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+#include <bitmap/impoctree.hxx>
+#include <bitmap/Octree.hxx>
+
+#include "impvect.hxx"
+#include "floyd.hxx"
+
+#include <math.h>
+#include <algorithm>
+#include <memory>
+
+#ifdef DBG_UTIL
+#include <cstdlib>
+#include <tools/stream.hxx>
+#include <vcl/graphicfilter.hxx>
+#endif
+
+Bitmap::Bitmap()
+{
+}
+
+Bitmap::Bitmap(const Bitmap& rBitmap)
+    : mxSalBmp(rBitmap.mxSalBmp)
+    , maPrefMapMode(rBitmap.maPrefMapMode)
+    , maPrefSize(rBitmap.maPrefSize)
+{
+}
+
+Bitmap::Bitmap(std::shared_ptr<SalBitmap> pSalBitmap)
+    : mxSalBmp(std::move(pSalBitmap))
+    , maPrefMapMode(MapMode(MapUnit::MapPixel))
+    , maPrefSize(mxSalBmp->GetSize())
+{
+}
+
+Bitmap::Bitmap( const Size& rSizePixel, vcl::PixelFormat ePixelFormat, const BitmapPalette* pPal )
+{
+    if (!(rSizePixel.Width() && rSizePixel.Height()))
+        return;
+
+    switch (ePixelFormat)
+    {
+        case vcl::PixelFormat::N8_BPP:
+        {
+            static const BitmapPalette aPalN8_BPP = [] {
+                BitmapPalette aPal(1 << sal_uInt16(vcl::PixelFormat::N8_BPP));
+                aPal[ 0 ] = COL_BLACK;
+                aPal[ 1 ] = COL_BLUE;
+                aPal[ 2 ] = COL_GREEN;
+                aPal[ 3 ] = COL_CYAN;
+                aPal[ 4 ] = COL_RED;
+                aPal[ 5 ] = COL_MAGENTA;
+                aPal[ 6 ] = COL_BROWN;
+                aPal[ 7 ] = COL_GRAY;
+                aPal[ 8 ] = COL_LIGHTGRAY;
+                aPal[ 9 ] = COL_LIGHTBLUE;
+                aPal[ 10 ] = COL_LIGHTGREEN;
+                aPal[ 11 ] = COL_LIGHTCYAN;
+                aPal[ 12 ] = COL_LIGHTRED;
+                aPal[ 13 ] = COL_LIGHTMAGENTA;
+                aPal[ 14 ] = COL_YELLOW;
+                aPal[ 15 ] = COL_WHITE;
+
+                // Create dither palette
+                sal_uInt16 nActCol = 16;
+
+                for( sal_uInt16 nB = 0; nB < 256; nB += 51 )
+                    for( sal_uInt16 nG = 0; nG < 256; nG += 51 )
+                        for( sal_uInt16 nR = 0; nR < 256; nR += 51 )
+                            aPal[ nActCol++ ] = BitmapColor( static_cast<sal_uInt8>(nR), static_cast<sal_uInt8>(nG), static_cast<sal_uInt8>(nB) );
+
+                // Set standard Office colors
+                aPal[ nActCol++ ] = BitmapColor( 0, 184, 255 );
+                return aPal;
+            }();
+            if (!pPal)
+                pPal = &aPalN8_BPP;
+            break;
+        }
+        default:
+        {
+            static const BitmapPalette aPalEmpty;
+            if (!pPal || !vcl::isPalettePixelFormat(ePixelFormat))
+                pPal = &aPalEmpty;
+            break;
+        }
+    }
+
+    mxSalBmp = ImplGetSVData()->mpDefInst->CreateSalBitmap();
+    mxSalBmp->Create(rSizePixel, ePixelFormat, *pPal);
+}
+
+#ifdef DBG_UTIL
+
+namespace
+{
+void savePNG(const OUString& sWhere, const Bitmap& rBmp)
+{
+    SvFileStream aStream(sWhere, StreamMode::WRITE | StreamMode::TRUNC);
+    GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter();
+    rFilter.compressAsPNG(BitmapEx(rBmp), aStream);
+}
+}
+
+#endif
+
+Bitmap::~Bitmap()
+{
+#ifdef DBG_UTIL
+    // VCL_DUMP_BMP_PATH should be like C:/path/ or ~/path/
+    static const OUString sDumpPath(OUString::createFromAscii(std::getenv("VCL_DUMP_BMP_PATH")));
+    // Stepping into the dtor of a bitmap you need, and setting the volatile variable to true in
+    // debugger, would dump the bitmap in question
+    static volatile bool save(false);
+    if (!sDumpPath.isEmpty() && save)
+    {
+        save = false;
+        savePNG(sDumpPath + "BitmapDump.png", *this);
+    }
+#endif
+}
+
+namespace
+{
+template <size_t N>
+constexpr std::enable_if_t<255 % (N - 1) == 0, std::array<BitmapColor, N>> getGreyscalePalette()
+{
+    const int step = 255 / (N - 1);
+    std::array<BitmapColor, N> a;
+    for (size_t i = 0; i < N; ++i)
+        a[i] = BitmapColor(i * step, i * step, i * step);
+    return a;
+}
+}
+
+const BitmapPalette& Bitmap::GetGreyPalette( int nEntries )
+{
+    // Create greyscale palette with 2, 4, 16 or 256 entries
+    switch (nEntries)
+    {
+        case 2:
+        {
+            static const BitmapPalette aGreyPalette2 = getGreyscalePalette<2>();
+            return aGreyPalette2;
+        }
+        case 4:
+        {
+            static const BitmapPalette aGreyPalette4 = getGreyscalePalette<4>();
+            return aGreyPalette4;
+        }
+        case 16:
+        {
+            static const BitmapPalette aGreyPalette16 = getGreyscalePalette<16>();
+            return aGreyPalette16;
+        }
+        case 256:
+        {
+            static const BitmapPalette aGreyPalette256 = getGreyscalePalette<256>();
+            return aGreyPalette256;
+        }
+    }
+    OSL_FAIL("Bitmap::GetGreyPalette: invalid entry count (2/4/16/256 allowed)");
+    return GetGreyPalette(2);
+}
+
+Bitmap& Bitmap::operator=( const Bitmap& rBitmap )
+{
+    if (this == &rBitmap)
+        return *this;
+
+    maPrefSize = rBitmap.maPrefSize;
+    maPrefMapMode = rBitmap.maPrefMapMode;
+    mxSalBmp = rBitmap.mxSalBmp;
+
+    return *this;
+}
+
+Bitmap& Bitmap::operator=( Bitmap&& rBitmap ) noexcept
+{
+    maPrefSize = std::move(rBitmap.maPrefSize);
+    maPrefMapMode = std::move(rBitmap.maPrefMapMode);
+    mxSalBmp = std::move(rBitmap.mxSalBmp);
+
+    return *this;
+}
+
+bool Bitmap::operator==( const Bitmap& rBmp ) const
+{
+    if (rBmp.mxSalBmp == mxSalBmp) // Includes both are nullptr
+        return true;
+    if (!rBmp.mxSalBmp || !mxSalBmp)
+        return false;
+    if (rBmp.mxSalBmp->GetSize() != mxSalBmp->GetSize() ||
+        rBmp.mxSalBmp->GetBitCount() != mxSalBmp->GetBitCount())
+        return false;
+    BitmapChecksum aChecksum1 = rBmp.mxSalBmp->GetChecksum();
+    BitmapChecksum aChecksum2 = mxSalBmp->GetChecksum();
+    // If the bitmaps can't calculate a checksum, best to regard them as different.
+    if (aChecksum1 == 0 || aChecksum2 == 0)
+        return false;
+    return aChecksum1 == aChecksum2;
+}
+
+void Bitmap::SetEmpty()
+{
+    maPrefMapMode = MapMode();
+    maPrefSize = Size();
+    mxSalBmp.reset();
+}
+
+Size Bitmap::GetSizePixel() const
+{
+    return( mxSalBmp ? mxSalBmp->GetSize() : Size() );
+}
+
+vcl::PixelFormat Bitmap::getPixelFormat() const
+{
+    if (!mxSalBmp)
+        return vcl::PixelFormat::INVALID;
+
+    sal_uInt16 nBitCount = mxSalBmp->GetBitCount();
+    if (nBitCount <= 8)
+        return vcl::PixelFormat::N8_BPP;
+    if (nBitCount <= 24)
+        return vcl::PixelFormat::N24_BPP;
+    if (nBitCount <= 32)
+        return vcl::PixelFormat::N32_BPP;
+
+    return vcl::PixelFormat::INVALID;
+}
+
+bool Bitmap::HasGreyPaletteAny() const
+{
+    bool bRet = false;
+
+    BitmapScopedInfoAccess pIAcc(*this);
+
+    if( pIAcc )
+    {
+        bRet = pIAcc->HasPalette() && pIAcc->GetPalette().IsGreyPaletteAny();
+    }
+
+    return bRet;
+}
+
+bool Bitmap::HasGreyPalette8Bit() const
+{
+    bool            bRet = false;
+    BitmapScopedInfoAccess pIAcc(*this);
+
+    if( pIAcc )
+    {
+        bRet = pIAcc->HasPalette() && pIAcc->GetPalette().IsGreyPalette8Bit();
+    }
+
+    return bRet;
+}
+
+BitmapChecksum Bitmap::GetChecksum() const
+{
+    if( !mxSalBmp )
+        return 0;
+
+    BitmapChecksum nRet = mxSalBmp->GetChecksum();
+    if (!nRet)
+    {
+        // nRet == 0 => probably, we were not able to acquire
+        // the buffer in SalBitmap::updateChecksum;
+        // so, we need to update the imp bitmap for this bitmap instance
+        // as we do in BitmapInfoAccess::ImplCreate
+        std::shared_ptr<SalBitmap> xNewImpBmp(ImplGetSVData()->mpDefInst->CreateSalBitmap());
+        if (xNewImpBmp->Create(*mxSalBmp, getPixelFormat()))
+        {
+            Bitmap* pThis = const_cast<Bitmap*>(this);
+            pThis->mxSalBmp = xNewImpBmp;
+            nRet = mxSalBmp->GetChecksum();
+        }
+    }
+
+    return nRet;
+}
+
+void Bitmap::ImplMakeUnique()
+{
+    if (mxSalBmp && mxSalBmp.use_count() > 1)
+    {
+        std::shared_ptr<SalBitmap> xOldImpBmp = mxSalBmp;
+        mxSalBmp = ImplGetSVData()->mpDefInst->CreateSalBitmap();
+        (void)mxSalBmp->Create(*xOldImpBmp);
+    }
+}
+
+void Bitmap::ReassignWithSize(const Bitmap& rBitmap)
+{
+    const Size aOldSizePix(GetSizePixel());
+    const Size aNewSizePix(rBitmap.GetSizePixel());
+    const MapMode aOldMapMode(maPrefMapMode);
+    Size aNewPrefSize;
+
+    if ((aOldSizePix != aNewSizePix) && aOldSizePix.Width() && aOldSizePix.Height())
+    {
+        aNewPrefSize.setWidth(FRound(maPrefSize.Width() * aNewSizePix.Width() / aOldSizePix.Width()));
+        aNewPrefSize.setHeight(FRound(maPrefSize.Height() * aNewSizePix.Height() / aOldSizePix.Height()));
+    }
+    else
+    {
+        aNewPrefSize = maPrefSize;
+    }
+
+    *this = rBitmap;
+
+    maPrefSize = aNewPrefSize;
+    maPrefMapMode = aOldMapMode;
+}
+
+void Bitmap::ImplSetSalBitmap(const std::shared_ptr<SalBitmap>& xImpBmp)
+{
+    mxSalBmp = xImpBmp;
+}
+
+bool Bitmap::Crop( const tools::Rectangle& rRectPixel )
+{
+    const Size          aSizePix( GetSizePixel() );
+    tools::Rectangle           aRect( rRectPixel );
+
+    aRect.Intersection( tools::Rectangle( Point(), aSizePix ) );
+
+    if( aRect.IsEmpty() || aSizePix == aRect.GetSize())
+        return false;
+
+    BitmapScopedReadAccess pReadAcc(*this);
+    if( !pReadAcc )
+        return false;
+
+    const tools::Rectangle     aNewRect( Point(), aRect.GetSize() );
+    Bitmap aNewBmp(aNewRect.GetSize(), getPixelFormat(), &pReadAcc->GetPalette());
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if( !pWriteAcc )
+        return false;
+
+    const tools::Long nOldX = aRect.Left();
+    const tools::Long nOldY = aRect.Top();
+    const tools::Long nNewWidth = aNewRect.GetWidth();
+    const tools::Long nNewHeight = aNewRect.GetHeight();
+
+    for( tools::Long nY = 0, nY2 = nOldY; nY < nNewHeight; nY++, nY2++ )
+    {
+        Scanline pScanline = pWriteAcc->GetScanline(nY);
+        Scanline pScanlineRead = pReadAcc->GetScanline(nY2);
+        for( tools::Long nX = 0, nX2 = nOldX; nX < nNewWidth; nX++, nX2++ )
+            pWriteAcc->SetPixelOnData( pScanline, nX, pReadAcc->GetPixelFromData( pScanlineRead, nX2 ) );
+    }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+
+    ReassignWithSize( aNewBmp );
+
+    return true;
+};
+
+bool Bitmap::CopyPixel( const tools::Rectangle& rRectDst,
+                        const tools::Rectangle& rRectSrc )
+{
+    const Size  aSizePix( GetSizePixel() );
+    tools::Rectangle   aRectDst( rRectDst );
+
+    aRectDst.Intersection( tools::Rectangle( Point(), aSizePix ) );
+
+    if( aRectDst.IsEmpty() )
+        return false;
+
+    tools::Rectangle aRectSrc( rRectSrc );
+
+    aRectSrc.Intersection( tools::Rectangle( Point(), aSizePix ) );
+
+    if( aRectSrc.IsEmpty() || ( aRectSrc == aRectDst ) )
+        return false;
+
+    BitmapScopedWriteAccess   pWriteAcc(*this);
+    if( !pWriteAcc )
+        return false;
+
+    const tools::Long  nWidth = std::min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
+    const tools::Long  nHeight = std::min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
+    const tools::Long  nSrcX = aRectSrc.Left();
+    const tools::Long  nSrcY = aRectSrc.Top();
+    const tools::Long  nSrcEndX1 = nSrcX + nWidth - 1;
+    const tools::Long  nSrcEndY1 = nSrcY + nHeight - 1;
+    const tools::Long  nDstX = aRectDst.Left();
+    const tools::Long  nDstY = aRectDst.Top();
+    const tools::Long  nDstEndX1 = nDstX + nWidth - 1;
+    const tools::Long  nDstEndY1 = nDstY + nHeight - 1;
+
+    if( ( nDstX <= nSrcX ) && ( nDstY <= nSrcY ) )
+    {
+        for( tools::Long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nYN);
+            Scanline pScanlineSrc = pWriteAcc->GetScanline(nY);
+            for( tools::Long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
+                pWriteAcc->SetPixelOnData( pScanline, nXN, pWriteAcc->GetPixelFromData( pScanlineSrc, nX ) );
+        }
+    }
+    else if( ( nDstX <= nSrcX ) && ( nDstY >= nSrcY ) )
+    {
+        for( tools::Long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nYN);
+            Scanline pScanlineSrc = pWriteAcc->GetScanline(nY);
+            for( tools::Long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
+                pWriteAcc->SetPixelOnData( pScanline, nXN, pWriteAcc->GetPixelFromData( pScanlineSrc, nX ) );
+        }
+    }
+    else if( ( nDstX >= nSrcX ) && ( nDstY <= nSrcY ) )
+    {
+        for( tools::Long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nYN);
+            Scanline pScanlineSrc = pWriteAcc->GetScanline(nY);
+            for( tools::Long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
+                pWriteAcc->SetPixelOnData( pScanline, nXN, pWriteAcc->GetPixelFromData( pScanlineSrc, nX ) );
+        }
+    }
+    else
+    {
+        for( tools::Long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nYN);
+            Scanline pScanlineSrc = pWriteAcc->GetScanline(nY);
+            for( tools::Long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
+                pWriteAcc->SetPixelOnData( pScanline, nXN, pWriteAcc->GetPixelFromData( pScanlineSrc, nX ) );
+        }
+    }
+
+    return true;
+}
+
+bool Bitmap::CopyPixel( const tools::Rectangle& rRectDst,
+                        const tools::Rectangle& rRectSrc, const Bitmap& rBmpSrc )
+{
+    const Size  aSizePix( GetSizePixel() );
+    tools::Rectangle   aRectDst( rRectDst );
+
+    aRectDst.Intersection( tools::Rectangle( Point(), aSizePix ) );
+
+    if( aRectDst.IsEmpty() )
+        return false;
+
+    if( rBmpSrc.mxSalBmp == mxSalBmp ) // if self-copy
+        return CopyPixel(rRectDst, rRectSrc);
+
+    Bitmap*         pSrc = &const_cast<Bitmap&>(rBmpSrc);
+    const Size      aCopySizePix( pSrc->GetSizePixel() );
+    tools::Rectangle       aRectSrc( rRectSrc );
+    const sal_uInt16 nSrcBitCount = vcl::pixelFormatBitCount(rBmpSrc.getPixelFormat());
+    const sal_uInt16 nDstBitCount = vcl::pixelFormatBitCount(getPixelFormat());
+
+    if( nSrcBitCount > nDstBitCount )
+    {
+        int nNextIndex = 0;
+
+        if (nSrcBitCount == 24)
+            Convert( BmpConversion::N24Bit );
+        else if (nSrcBitCount == 8)
+        {
+            Convert( BmpConversion::N8BitColors );
+            nNextIndex = 16;
+        }
+        else if (nSrcBitCount == 4)
+        {
+            assert(false);
+        }
+
+        if( nNextIndex )
+        {
+            BitmapScopedReadAccess  pSrcAcc(*pSrc);
+            BitmapScopedWriteAccess pDstAcc(*this);
+
+            if( pSrcAcc && pDstAcc )
+            {
+                const int nSrcCount = pSrcAcc->GetPaletteEntryCount();
+                const int nDstCount = 1 << nDstBitCount;
+
+                for (int i = 0; ( i < nSrcCount ) && ( nNextIndex < nDstCount ); ++i)
+                {
+                    const BitmapColor& rSrcCol = pSrcAcc->GetPaletteColor( static_cast<sal_uInt16>(i) );
+
+                    bool bFound = false;
+
+                    for (int j = 0; j < nDstCount; ++j)
+                    {
+                        if( rSrcCol == pDstAcc->GetPaletteColor( static_cast<sal_uInt16>(j) ) )
+                        {
+                            bFound = true;
+                            break;
+                        }
+                    }
+
+                    if( !bFound )
+                        pDstAcc->SetPaletteColor( static_cast<sal_uInt16>(nNextIndex++), rSrcCol );
+                }
+            }
+        }
+    }
+
+    aRectSrc.Intersection( tools::Rectangle( Point(), aCopySizePix ) );
+
+    if( aRectSrc.IsEmpty() )
+        return false;
+
+    BitmapScopedReadAccess pReadAcc(*pSrc);
+    if( !pReadAcc )
+        return false;
+
+    BitmapScopedWriteAccess pWriteAcc(*this);
+    if( !pWriteAcc )
+        return false;
+
+    const tools::Long  nWidth = std::min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
+    const tools::Long  nHeight = std::min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
+    const tools::Long  nSrcEndX = aRectSrc.Left() + nWidth;
+    const tools::Long  nSrcEndY = aRectSrc.Top() + nHeight;
+    tools::Long        nDstY = aRectDst.Top();
+
+    if( pReadAcc->HasPalette() && pWriteAcc->HasPalette() )
+    {
+        const sal_uInt16    nCount = pReadAcc->GetPaletteEntryCount();
+        std::unique_ptr<sal_uInt8[]> pMap(new sal_uInt8[ nCount ]);
+
+        // Create index map for the color table, as the bitmap should be copied
+        // retaining it's color information relatively well
+        for( sal_uInt16 i = 0; i < nCount; i++ )
+            pMap[ i ] = static_cast<sal_uInt8>(pWriteAcc->GetBestPaletteIndex( pReadAcc->GetPaletteColor( i ) ));
+
+        for( tools::Long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nDstY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nSrcY);
+            for( tools::Long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
+                pWriteAcc->SetPixelOnData( pScanline, nDstX, BitmapColor( pMap[ pReadAcc->GetIndexFromData( pScanlineRead, nSrcX ) ] ));
+        }
+    }
+    else if( pReadAcc->HasPalette() )
+    {
+        for( tools::Long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nDstY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nSrcY);
+            for( tools::Long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
+                pWriteAcc->SetPixelOnData( pScanline, nDstX, pReadAcc->GetPaletteColor( pReadAcc->GetIndexFromData( pScanlineRead, nSrcX ) ) );
+        }
+    }
+    else
+        for( tools::Long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nDstY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nSrcY);
+            for( tools::Long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
+                pWriteAcc->SetPixelOnData( pScanline, nDstX, pReadAcc->GetPixelFromData( pScanlineRead, nSrcX ) );
+        }
+
+    bool bRet = ( nWidth > 0 ) && ( nHeight > 0 );
+
+    return bRet;
+}
+
+bool Bitmap::CopyPixel_AlphaOptimized( const tools::Rectangle& rRectDst, const tools::Rectangle& rRectSrc )
+{
+    assert(HasGreyPalette8Bit());
+    // Note: this code is copied from Bitmap::CopyPixel but avoids any palette lookups
+    // This optimization is possible because the palettes of AlphaMasks are always identical (8bit GreyPalette, see ctor)
+    const Size  aSizePix( GetSizePixel() );
+    tools::Rectangle   aRectDst( rRectDst );
+
+    aRectDst.Intersection( tools::Rectangle( Point(), aSizePix ) );
+
+    if( aRectDst.IsEmpty() )
+        return false;
+
+    tools::Rectangle aRectSrc( rRectSrc );
+    aRectSrc.Intersection( tools::Rectangle( Point(), aSizePix ) );
+    if( aRectSrc.IsEmpty() || ( aRectSrc == aRectDst ) )
+        return false;
+
+    BitmapScopedWriteAccess   pWriteAcc(*this);
+    if( !pWriteAcc )
+        return false;
+
+    const tools::Long  nWidth = std::min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
+    const tools::Long  nHeight = std::min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
+    const tools::Long  nSrcX = aRectSrc.Left();
+    const tools::Long  nSrcY = aRectSrc.Top();
+    const tools::Long  nSrcEndX1 = nSrcX + nWidth - 1;
+    const tools::Long  nSrcEndY1 = nSrcY + nHeight - 1;
+    const tools::Long  nDstX = aRectDst.Left();
+    const tools::Long  nDstY = aRectDst.Top();
+    const tools::Long  nDstEndX1 = nDstX + nWidth - 1;
+    const tools::Long  nDstEndY1 = nDstY + nHeight - 1;
+
+    if( ( nDstX <= nSrcX ) && ( nDstY <= nSrcY ) )
+    {
+        for( tools::Long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nYN);
+            Scanline pScanlineSrc = pWriteAcc->GetScanline(nY);
+            for( tools::Long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
+                pWriteAcc->SetPixelOnData( pScanline, nXN, pWriteAcc->GetPixelFromData( pScanlineSrc, nX ) );
+        }
+    }
+    else if( ( nDstX <= nSrcX ) && ( nDstY >= nSrcY ) )
+    {
+        for( tools::Long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nYN);
+            Scanline pScanlineSrc = pWriteAcc->GetScanline(nY);
+            for( tools::Long nX = nSrcX, nXN = nDstX; nX <= nSrcEndX1; nX++, nXN++ )
+                pWriteAcc->SetPixelOnData( pScanline, nXN, pWriteAcc->GetPixelFromData( pScanlineSrc, nX ) );
+        }
+    }
+    else if( ( nDstX >= nSrcX ) && ( nDstY <= nSrcY ) )
+    {
+        for( tools::Long nY = nSrcY, nYN = nDstY; nY <= nSrcEndY1; nY++, nYN++ )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nYN);
+            Scanline pScanlineSrc = pWriteAcc->GetScanline(nY);
+            for( tools::Long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
+                pWriteAcc->SetPixelOnData( pScanline, nXN, pWriteAcc->GetPixelFromData( pScanlineSrc, nX ) );
+        }
+    }
+    else
+    {
+        for( tools::Long nY = nSrcEndY1, nYN = nDstEndY1; nY >= nSrcY; nY--, nYN-- )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nYN);
+            Scanline pScanlineSrc = pWriteAcc->GetScanline(nY);
+            for( tools::Long nX = nSrcEndX1, nXN = nDstEndX1; nX >= nSrcX; nX--, nXN-- )
+                pWriteAcc->SetPixelOnData( pScanline, nXN, pWriteAcc->GetPixelFromData( pScanlineSrc, nX ) );
+        }
+    }
+
+    return true;
+}
+
+bool Bitmap::CopyPixel_AlphaOptimized( const tools::Rectangle& rRectDst, const tools::Rectangle& rRectSrc,
+                           const AlphaMask& rBmpSrc )
+{
+    assert(HasGreyPalette8Bit());
+    assert(rBmpSrc.GetBitmap().HasGreyPalette8Bit());
+    // Note: this code is copied from Bitmap::CopyPixel but avoids any palette lookups
+    // This optimization is possible because the palettes of AlphaMasks are always identical (8bit GreyPalette, see ctor)
+    const Size  aSizePix( GetSizePixel() );
+    tools::Rectangle   aRectDst( rRectDst );
+
+    aRectDst.Intersection( tools::Rectangle( Point(), aSizePix ) );
+
+    if( aRectDst.IsEmpty() )
+        return false;
+
+    if( rBmpSrc.GetBitmap().mxSalBmp == mxSalBmp ) // self-copy
+        return CopyPixel_AlphaOptimized(rRectDst, rRectSrc);
+
+    Bitmap*         pSrc = &const_cast<Bitmap&>(rBmpSrc.GetBitmap());
+    const Size      aCopySizePix( pSrc->GetSizePixel() );
+    tools::Rectangle       aRectSrc( rRectSrc );
+
+    aRectSrc.Intersection( tools::Rectangle( Point(), aCopySizePix ) );
+    if( aRectSrc.IsEmpty() )
+        return false;
+
+    BitmapScopedReadAccess pReadAcc(*pSrc);
+    if( !pReadAcc )
+        return false;
+
+    BitmapScopedWriteAccess pWriteAcc(*this);
+    if( !pWriteAcc )
+        return false;
+
+    const tools::Long  nWidth = std::min( aRectSrc.GetWidth(), aRectDst.GetWidth() );
+    const tools::Long  nHeight = std::min( aRectSrc.GetHeight(), aRectDst.GetHeight() );
+    const tools::Long  nSrcEndX = aRectSrc.Left() + nWidth;
+    const tools::Long  nSrcEndY = aRectSrc.Top() + nHeight;
+    tools::Long        nDstY = aRectDst.Top();
+
+    for( tools::Long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++)
+    {
+        Scanline pScanline = pWriteAcc->GetScanline(nDstY);
+        Scanline pScanlineRead = pReadAcc->GetScanline(nSrcY);
+        for( tools::Long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
+            pWriteAcc->SetPixelOnData( pScanline, nDstX, pReadAcc->GetPixelFromData( pScanlineRead, nSrcX ) );
+    }
+
+    bool bRet = ( nWidth > 0 ) && ( nHeight > 0 );
+
+    return bRet;
+}
+
+bool Bitmap::Expand( sal_Int32 nDX, sal_Int32 nDY, const Color* pInitColor )
+{
+    if( !nDX && !nDY )
+        return false;
+
+    const Size          aSizePixel( GetSizePixel() );
+    const tools::Long          nWidth = aSizePixel.Width();
+    const tools::Long          nHeight = aSizePixel.Height();
+    const Size          aNewSize( nWidth + nDX, nHeight + nDY );
+    BitmapScopedReadAccess pReadAcc(*this);
+    if( !pReadAcc )
+        return false;
+
+    BitmapPalette       aBmpPal( pReadAcc->GetPalette() );
+    Bitmap aNewBmp(aNewSize, getPixelFormat(), &aBmpPal);
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if( !pWriteAcc )
+        return false;
+
+    BitmapColor aColor;
+    const tools::Long  nNewX = nWidth;
+    const tools::Long  nNewY = nHeight;
+    const tools::Long  nNewWidth = pWriteAcc->Width();
+    const tools::Long  nNewHeight = pWriteAcc->Height();
+    tools::Long        nX;
+    tools::Long        nY;
+
+    if( pInitColor )
+        aColor = pWriteAcc->GetBestMatchingColor( *pInitColor );
+
+    for( nY = 0; nY < nHeight; nY++ )
+    {
+        pWriteAcc->CopyScanline( nY, *pReadAcc );
+
+        if( pInitColor && nDX )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            for( nX = nNewX; nX < nNewWidth; nX++ )
+                pWriteAcc->SetPixelOnData( pScanline, nX, aColor );
+        }
+    }
+
+    if( pInitColor && nDY )
+        for( nY = nNewY; nY < nNewHeight; nY++ )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            for( nX = 0; nX < nNewWidth; nX++ )
+                pWriteAcc->SetPixelOnData( pScanline, nX, aColor );
+        }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+
+    ReassignWithSize(aNewBmp);
+
+    return true;
+}
+
+Bitmap Bitmap::CreateDisplayBitmap( OutputDevice* pDisplay ) const
+{
+    Bitmap aDispBmp( *this );
+
+    SalGraphics* pDispGraphics = pDisplay->GetGraphics();
+
+    if( mxSalBmp && pDispGraphics )
+    {
+        std::shared_ptr<SalBitmap> xImpDispBmp(ImplGetSVData()->mpDefInst->CreateSalBitmap());
+        if (xImpDispBmp->Create(*mxSalBmp, pDispGraphics))
+            aDispBmp.ImplSetSalBitmap(xImpDispBmp);
+    }
+
+    return aDispBmp;
+}
+
+bool Bitmap::GetSystemData( BitmapSystemData& rData ) const
+{
+    return mxSalBmp && mxSalBmp->GetSystemData(rData);
+}
+
+
+bool Bitmap::Convert( BmpConversion eConversion )
+{
+    // try to convert in backend
+    if (mxSalBmp)
+    {
+        // avoid large chunk of obsolete and hopefully rarely used conversions.
+        if (eConversion == BmpConversion::N8BitNoConversion)
+        {
+            if (mxSalBmp->GetBitCount() == 8 && HasGreyPalette8Bit())
+                return true;
+            std::shared_ptr<SalBitmap> xImpBmp(ImplGetSVData()->mpDefInst->CreateSalBitmap());
+            // frequently used conversion for creating alpha masks
+            if (xImpBmp->Create(*mxSalBmp) && xImpBmp->InterpretAs8Bit())
+            {
+                ImplSetSalBitmap(xImpBmp);
+                SAL_INFO( "vcl.opengl", "Ref count: " << mxSalBmp.use_count() );
+                return true;
+            }
+        }
+        if (eConversion == BmpConversion::N8BitGreys)
+        {
+            std::shared_ptr<SalBitmap> xImpBmp(ImplGetSVData()->mpDefInst->CreateSalBitmap());
+            if (xImpBmp->Create(*mxSalBmp) && xImpBmp->ConvertToGreyscale())
+            {
+                ImplSetSalBitmap(xImpBmp);
+                SAL_INFO( "vcl.opengl", "Ref count: " << mxSalBmp.use_count() );
+                return true;
+            }
+        }
+    }
+
+    const sal_uInt16 nBitCount = vcl::pixelFormatBitCount(getPixelFormat());
+    bool bRet = false;
+
+    switch( eConversion )
+    {
+        case BmpConversion::N1BitThreshold:
+        {
+            BitmapEx aBmpEx(*this);
+            bRet = BitmapFilter::Filter(aBmpEx, BitmapMonochromeFilter(128));
+            *this = aBmpEx.GetBitmap();
+        }
+        break;
+
+        case BmpConversion::N8BitGreys:
+        case BmpConversion::N8BitNoConversion:
+            bRet = ImplMakeGreyscales();
+        break;
+
+        case BmpConversion::N8BitColors:
+        {
+            if( nBitCount < 8 )
+                bRet = ImplConvertUp(vcl::PixelFormat::N8_BPP);
+            else if( nBitCount > 8 )
+                bRet = ImplConvertDown8BPP();
+            else
+                bRet = true;
+        }
+        break;
+
+        case BmpConversion::N8BitTrans:
+        {
+            Color aTrans( BMP_COL_TRANS );
+
+            if( nBitCount < 8 )
+                bRet = ImplConvertUp(vcl::PixelFormat::N8_BPP, &aTrans );
+            else
+                bRet = ImplConvertDown8BPP(&aTrans );
+        }
+        break;
+
+        case BmpConversion::N24Bit:
+        {
+            if( nBitCount < 24 )
+                bRet = ImplConvertUp(vcl::PixelFormat::N24_BPP);
+            else
+                bRet = true;
+        }
+        break;
+
+        case BmpConversion::N32Bit:
+        {
+            if( nBitCount < 32 )
+                bRet = ImplConvertUp(vcl::PixelFormat::N32_BPP);
+            else
+                bRet = true;
+        }
+        break;
+
+        default:
+            OSL_FAIL( "Bitmap::Convert(): Unsupported conversion" );
+        break;
+    }
+
+    return bRet;
+}
+
+bool Bitmap::ImplMakeGreyscales()
+{
+    BitmapScopedReadAccess pReadAcc(*this);
+    if( !pReadAcc )
+        return false;
+
+    const BitmapPalette& rPal = GetGreyPalette(256);
+    sal_uLong nShift = 0;
+    bool bPalDiffers = !pReadAcc->HasPalette() || ( rPal.GetEntryCount() != pReadAcc->GetPaletteEntryCount() );
+
+    if( !bPalDiffers )
+        bPalDiffers = ( rPal != pReadAcc->GetPalette() );
+    if( !bPalDiffers )
+        return true;
+
+    const auto ePixelFormat = vcl::PixelFormat::N8_BPP;
+    Bitmap aNewBmp(GetSizePixel(), ePixelFormat, &rPal );
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if( !pWriteAcc )
+        return false;
+
+    const tools::Long nWidth = pWriteAcc->Width();
+    const tools::Long nHeight = pWriteAcc->Height();
+
+    if( pReadAcc->HasPalette() )
+    {
+        for( tools::Long nY = 0; nY < nHeight; nY++ )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+            for( tools::Long nX = 0; nX < nWidth; nX++ )
+            {
+                const sal_uInt8 cIndex = pReadAcc->GetIndexFromData( pScanlineRead, nX );
+                pWriteAcc->SetPixelOnData( pScanline, nX,
+                    BitmapColor(pReadAcc->GetPaletteColor( cIndex ).GetLuminance() >> nShift) );
+            }
+        }
+    }
+    else if( pReadAcc->GetScanlineFormat() == ScanlineFormat::N24BitTcBgr &&
+             pWriteAcc->GetScanlineFormat() == ScanlineFormat::N8BitPal )
+    {
+        nShift += 8;
+
+        for( tools::Long nY = 0; nY < nHeight; nY++ )
+        {
+            Scanline pReadScan = pReadAcc->GetScanline( nY );
+            Scanline pWriteScan = pWriteAcc->GetScanline( nY );
+
+            for( tools::Long nX = 0; nX < nWidth; nX++ )
+            {
+                const sal_uLong nB = *pReadScan++;
+                const sal_uLong nG = *pReadScan++;
+                const sal_uLong nR = *pReadScan++;
+
+                *pWriteScan++ = static_cast<sal_uInt8>( ( nB * 28UL + nG * 151UL + nR * 77UL ) >> nShift );
+            }
+        }
+    }
+    else if( pReadAcc->GetScanlineFormat() == ScanlineFormat::N24BitTcRgb &&
+             pWriteAcc->GetScanlineFormat() == ScanlineFormat::N8BitPal )
+    {
+        nShift += 8;
+
+        for( tools::Long nY = 0; nY < nHeight; nY++ )
+        {
+            Scanline pReadScan = pReadAcc->GetScanline( nY );
+            Scanline pWriteScan = pWriteAcc->GetScanline( nY );
+
+            for( tools::Long nX = 0; nX < nWidth; nX++ )
+            {
+                const sal_uLong nR = *pReadScan++;
+                const sal_uLong nG = *pReadScan++;
+                const sal_uLong nB = *pReadScan++;
+
+                *pWriteScan++ = static_cast<sal_uInt8>( ( nB * 28UL + nG * 151UL + nR * 77UL ) >> nShift );
+            }
+        }
+    }
+    else
+    {
+        for( tools::Long nY = 0; nY < nHeight; nY++ )
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+            for( tools::Long nX = 0; nX < nWidth; nX++ )
+                pWriteAcc->SetPixelOnData( pScanline, nX, BitmapColor(pReadAcc->GetPixelFromData( pScanlineRead, nX ).GetLuminance() >> nShift) );
+        }
+    }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+
+    const MapMode aMap( maPrefMapMode );
+    const Size aSize( maPrefSize );
+
+    *this = aNewBmp;
+
+    maPrefMapMode = aMap;
+    maPrefSize = aSize;
+
+    return true;
+}
+
+bool Bitmap::ImplConvertUp(vcl::PixelFormat ePixelFormat, Color const * pExtColor)
+{
+    SAL_WARN_IF(ePixelFormat <= getPixelFormat(), "vcl", "New pixel format must be greater!" );
+
+    BitmapScopedReadAccess pReadAcc(*this);
+    if (!pReadAcc)
+        return false;
+
+    BitmapPalette aPalette;
+    Bitmap aNewBmp(GetSizePixel(), ePixelFormat, pReadAcc->HasPalette() ? &pReadAcc->GetPalette() : &aPalette);
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if (!pWriteAcc)
+        return false;
+
+    const tools::Long nWidth = pWriteAcc->Width();
+    const tools::Long nHeight = pWriteAcc->Height();
+
+    if (pWriteAcc->HasPalette())
+    {
+        const BitmapPalette& rOldPalette = pReadAcc->GetPalette();
+        const sal_uInt16 nOldCount = rOldPalette.GetEntryCount();
+        assert(nOldCount <= (1 << vcl::pixelFormatBitCount(getPixelFormat())));
+
+        aPalette.SetEntryCount(1 << vcl::pixelFormatBitCount(ePixelFormat));
+
+        for (sal_uInt16 i = 0; i < nOldCount; i++)
+            aPalette[i] = rOldPalette[i];
+
+        if (pExtColor)
+            aPalette[aPalette.GetEntryCount() - 1] = *pExtColor;
+
+        pWriteAcc->SetPalette(aPalette);
+
+        for (tools::Long nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+            for (tools::Long nX = 0; nX < nWidth; nX++)
+            {
+                pWriteAcc->SetPixelOnData(pScanline, nX, pReadAcc->GetPixelFromData(pScanlineRead, nX));
+            }
+        }
+    }
+    else
+    {
+        if (pReadAcc->HasPalette())
+        {
+            for (tools::Long nY = 0; nY < nHeight; nY++)
+            {
+                Scanline pScanline = pWriteAcc->GetScanline(nY);
+                Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+                for (tools::Long nX = 0; nX < nWidth; nX++)
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, pReadAcc->GetPaletteColor(pReadAcc->GetIndexFromData(pScanlineRead, nX)));
+                }
+            }
+        }
+        else
+        {
+            for (tools::Long nY = 0; nY < nHeight; nY++)
+            {
+                Scanline pScanline = pWriteAcc->GetScanline(nY);
+                Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+                for (tools::Long nX = 0; nX < nWidth; nX++)
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, pReadAcc->GetPixelFromData(pScanlineRead, nX));
+                }
+            }
+        }
+    }
+
+    const MapMode aMap(maPrefMapMode);
+    const Size aSize(maPrefSize);
+
+    *this = aNewBmp;
+
+    maPrefMapMode = aMap;
+    maPrefSize = aSize;
+
+    return true;
+}
+
+bool Bitmap::ImplConvertDown8BPP(Color const * pExtColor)
+{
+    SAL_WARN_IF(vcl::PixelFormat::N8_BPP > getPixelFormat(), "vcl", "New pixelformat must be lower ( or equal when pExtColor is set )!");
+
+    BitmapScopedReadAccess pReadAcc(*this);
+    if (!pReadAcc)
+        return false;
+
+    BitmapPalette aPalette;
+    Bitmap aNewBmp(GetSizePixel(), vcl::PixelFormat::N8_BPP, &aPalette);
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if (!pWriteAcc)
+        return false;
+
+    sal_Int16 nNewBitCount = sal_Int16(vcl::PixelFormat::N8_BPP);
+    const sal_uInt16 nCount = 1 << nNewBitCount;
+    const tools::Long nWidth = pWriteAcc->Width();
+    const tools::Long nWidth1 = nWidth - 1;
+    const tools::Long nHeight = pWriteAcc->Height();
+    Octree aOctree(*pReadAcc, pExtColor ? (nCount - 1) : nCount);
+    aPalette = aOctree.GetPalette();
+    InverseColorMap aColorMap(aPalette);
+    BitmapColor aColor;
+    ImpErrorQuad aErrQuad;
+    std::vector<ImpErrorQuad> aErrQuad1(nWidth);
+    std::vector<ImpErrorQuad> aErrQuad2(nWidth);
+    ImpErrorQuad* pQLine1 = aErrQuad1.data();
+    ImpErrorQuad* pQLine2 = nullptr;
+    tools::Long nYTmp = 0;
+    sal_uInt8 cIndex;
+    bool bQ1 = true;
+
+    if (pExtColor)
+    {
+        aPalette.SetEntryCount(aPalette.GetEntryCount() + 1);
+        aPalette[aPalette.GetEntryCount() - 1] = *pExtColor;
+    }
+
+    // set Black/White always, if we have enough space
+    if (aPalette.GetEntryCount() < (nCount - 1))
+    {
+        aPalette.SetEntryCount(aPalette.GetEntryCount() + 2);
+        aPalette[aPalette.GetEntryCount() - 2] = COL_BLACK;
+        aPalette[aPalette.GetEntryCount() - 1] = COL_WHITE;
+    }
+
+    pWriteAcc->SetPalette(aPalette);
+
+    for (tools::Long nY = 0; nY < std::min(nHeight, tools::Long(2)); nY++, nYTmp++)
+    {
+        pQLine2 = !nY ? aErrQuad1.data() : aErrQuad2.data();
+        Scanline pScanlineRead = pReadAcc->GetScanline(nYTmp);
+        for (tools::Long nX = 0; nX < nWidth; nX++)
+        {
+            if (pReadAcc->HasPalette())
+                pQLine2[nX] = pReadAcc->GetPaletteColor(pReadAcc->GetIndexFromData(pScanlineRead, nX));
+            else
+                pQLine2[nX] = pReadAcc->GetPixelFromData(pScanlineRead, nX);
+        }
+    }
+
+    assert(pQLine2 || nHeight == 0);
+
+    for (tools::Long nY = 0; nY < nHeight; nY++, nYTmp++)
+    {
+        // first pixel in the line
+        cIndex = static_cast<sal_uInt8>(aColorMap.GetBestPaletteIndex(pQLine1[0].ImplGetColor()));
+        Scanline pScanline = pWriteAcc->GetScanline(nY);
+        pWriteAcc->SetPixelOnData(pScanline, 0, BitmapColor(cIndex));
+
+        tools::Long nX;
+        for (nX = 1; nX < nWidth1; nX++)
+        {
+            aColor = pQLine1[nX].ImplGetColor();
+            cIndex = static_cast<sal_uInt8>(aColorMap.GetBestPaletteIndex(aColor));
+            aErrQuad = (ImpErrorQuad(aColor) -= pWriteAcc->GetPaletteColor(cIndex));
+            pQLine1[++nX].ImplAddColorError7(aErrQuad);
+            pQLine2[nX--].ImplAddColorError1(aErrQuad);
+            pQLine2[nX--].ImplAddColorError5(aErrQuad);
+            pQLine2[nX++].ImplAddColorError3(aErrQuad);
+            pWriteAcc->SetPixelOnData(pScanline, nX, BitmapColor(cIndex));
+        }
+
+        // Last RowPixel
+        if (nX < nWidth)
+        {
+            cIndex = static_cast<sal_uInt8>(aColorMap.GetBestPaletteIndex(pQLine1[nWidth1].ImplGetColor()));
+            pWriteAcc->SetPixelOnData(pScanline, nX, BitmapColor(cIndex));
+        }
+
+        // Refill/copy row buffer
+        pQLine1 = pQLine2;
+        bQ1 = !bQ1;
+        pQLine2 = bQ1 ? aErrQuad2.data() : aErrQuad1.data();
+
+        if (nYTmp < nHeight)
+        {
+            Scanline pScanlineRead = pReadAcc->GetScanline(nYTmp);
+            for (nX = 0; nX < nWidth; nX++)
+            {
+                if (pReadAcc->HasPalette())
+                    pQLine2[nX] = pReadAcc->GetPaletteColor(pReadAcc->GetIndexFromData(pScanlineRead, nX));
+                else
+                    pQLine2[nX] = pReadAcc->GetPixelFromData(pScanlineRead, nX);
+            }
+        }
+    }
+
+    pWriteAcc.reset();
+
+    const MapMode aMap(maPrefMapMode);
+    const Size aSize(maPrefSize);
+
+    *this = aNewBmp;
+
+    maPrefMapMode = aMap;
+    maPrefSize = aSize;
+
+    return true;
+}
+
+bool Bitmap::Scale( const double& rScaleX, const double& rScaleY, BmpScaleFlag nScaleFlag )
+{
+    if(basegfx::fTools::equalZero(rScaleX) || basegfx::fTools::equalZero(rScaleY))
+    {
+        // no scale
+        return true;
+    }
+
+    if(basegfx::fTools::equal(rScaleX, 1.0) && basegfx::fTools::equal(rScaleY, 1.0))
+    {
+        // no scale
+        return true;
+    }
+
+    const auto eStartPixelFormat = getPixelFormat();
+
+    if (mxSalBmp && mxSalBmp->ScalingSupported())
+    {
+        // implementation specific scaling
+        std::shared_ptr<SalBitmap> xImpBmp(ImplGetSVData()->mpDefInst->CreateSalBitmap());
+        if (xImpBmp->Create(*mxSalBmp) && xImpBmp->Scale(rScaleX, rScaleY, nScaleFlag))
+        {
+            ImplSetSalBitmap(xImpBmp);
+            SAL_INFO( "vcl.opengl", "Ref count: " << mxSalBmp.use_count() );
+            maPrefMapMode = MapMode( MapUnit::MapPixel );
+            maPrefSize = xImpBmp->GetSize();
+            return true;
+        }
+    }
+
+    BitmapEx aBmpEx(*this);
+    bool bRetval(false);
+
+    switch(nScaleFlag)
+    {
+        case BmpScaleFlag::Default:
+            if (GetSizePixel().Width() < 2 || GetSizePixel().Height() < 2)
+                bRetval = BitmapFilter::Filter(aBmpEx, BitmapFastScaleFilter(rScaleX, rScaleY));
+            else
+                bRetval = BitmapFilter::Filter(aBmpEx, BitmapScaleSuperFilter(rScaleX, rScaleY));
+            break;
+
+        case BmpScaleFlag::Fast:
+        case BmpScaleFlag::NearestNeighbor:
+            bRetval = BitmapFilter::Filter(aBmpEx, BitmapFastScaleFilter(rScaleX, rScaleY));
+            break;
+
+        case BmpScaleFlag::Interpolate:
+            bRetval = BitmapFilter::Filter(aBmpEx, BitmapInterpolateScaleFilter(rScaleX, rScaleY));
+            break;
+
+        case BmpScaleFlag::BestQuality:
+        case BmpScaleFlag::Lanczos:
+            bRetval = BitmapFilter::Filter(aBmpEx, vcl::BitmapScaleLanczos3Filter(rScaleX, rScaleY));
+            break;
+
+        case BmpScaleFlag::BiCubic:
+            bRetval = BitmapFilter::Filter(aBmpEx, vcl::BitmapScaleBicubicFilter(rScaleX, rScaleY));
+            break;
+
+        case BmpScaleFlag::BiLinear:
+            bRetval = BitmapFilter::Filter(aBmpEx, vcl::BitmapScaleBilinearFilter(rScaleX, rScaleY));
+            break;
+    }
+
+    if (bRetval)
+        *this = aBmpEx.GetBitmap();
+
+    OSL_ENSURE(!bRetval || eStartPixelFormat == getPixelFormat(), "Bitmap::Scale has changed the ColorDepth, this should *not* happen (!)");
+    return bRetval;
+}
+
+bool Bitmap::Scale( const Size& rNewSize, BmpScaleFlag nScaleFlag )
+{
+    const Size aSize( GetSizePixel() );
+    bool bRet;
+
+    if( aSize.Width() && aSize.Height() )
+    {
+        bRet = Scale( static_cast<double>(rNewSize.Width()) / aSize.Width(),
+                      static_cast<double>(rNewSize.Height()) / aSize.Height(),
+                      nScaleFlag );
+    }
+    else
+        bRet = true;
+
+    return bRet;
+}
+
+bool Bitmap::HasFastScale()
+{
+#if HAVE_FEATURE_SKIA
+    if( SkiaHelper::isVCLSkiaEnabled() && SkiaHelper::renderMethodToUse() != SkiaHelper::RenderRaster)
+        return true;
+#endif
+    return false;
+}
+
+void Bitmap::AdaptBitCount(Bitmap& rNew) const
+{
+    // aNew is the result of some operation; adapt it's BitCount to the original (this)
+    if (getPixelFormat() == rNew.getPixelFormat())
+        return;
+
+    switch (getPixelFormat())
+    {
+        case vcl::PixelFormat::N8_BPP:
+        {
+            if(HasGreyPaletteAny())
+            {
+                rNew.Convert(BmpConversion::N8BitGreys);
+            }
+            else
+            {
+                rNew.Convert(BmpConversion::N8BitColors);
+            }
+            break;
+        }
+        case vcl::PixelFormat::N24_BPP:
+        {
+            rNew.Convert(BmpConversion::N24Bit);
+            break;
+        }
+        case vcl::PixelFormat::N32_BPP:
+        {
+            rNew.Convert(BmpConversion::N32Bit);
+            break;
+        }
+        case vcl::PixelFormat::INVALID:
+        {
+            SAL_WARN("vcl", "Can't adapt the pixelformat as it is invalid.");
+            break;
+        }
+    }
+}
+
+static void shiftColors(sal_Int32* pColorArray, const BitmapScopedReadAccess& pReadAcc)
+{
+    Scanline pScanlineRead = pReadAcc->GetScanline(0); // Why always 0?
+    for (tools::Long n = 0; n < pReadAcc->Width(); ++n)
+    {
+        const BitmapColor& rColor = pReadAcc->GetColorFromData(pScanlineRead, n);
+        *pColorArray++ = static_cast<sal_Int32>(rColor.GetBlue()) << 12;
+        *pColorArray++ = static_cast<sal_Int32>(rColor.GetGreen()) << 12;
+        *pColorArray++ = static_cast<sal_Int32>(rColor.GetRed()) << 12;
+    }
+}
+
+bool Bitmap::Dither()
+{
+    const Size aSize( GetSizePixel() );
+    if( aSize.Width() == 1 || aSize.Height() == 1 )
+        return true;
+    if( ( aSize.Width() <= 3 ) || ( aSize.Height() <= 2 ) )
+        return false;
+
+    BitmapScopedReadAccess pReadAcc(*this);
+    Bitmap aNewBmp(GetSizePixel(), vcl::PixelFormat::N8_BPP);
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if( !pReadAcc || !pWriteAcc )
+        return false;
+
+    tools::Long nWidth = pReadAcc->Width();
+    tools::Long nWidth1 = nWidth - 1;
+    tools::Long nHeight = pReadAcc->Height();
+    tools::Long nW = nWidth * 3;
+    tools::Long nW2 = nW - 3;
+    std::unique_ptr<sal_Int32[]> p1(new sal_Int32[ nW ]);
+    std::unique_ptr<sal_Int32[]> p2(new sal_Int32[ nW ]);
+    sal_Int32* p1T = p1.get();
+    sal_Int32* p2T = p2.get();
+    shiftColors(p2T, pReadAcc);
+    for( tools::Long nYAcc = 0; nYAcc < nHeight; nYAcc++ )
+    {
+        std::swap(p1T, p2T);
+        if (nYAcc < nHeight - 1)
+            shiftColors(p2T, pReadAcc);
+
+        auto CalcError = [](tools::Long n)
+        {
+            n = std::clamp<tools::Long>(n >> 12, 0, 255);
+            return std::pair(FloydErrMap[n], FloydMap[n]);
+        };
+
+        auto CalcErrors = [&](tools::Long n)
+        { return std::tuple_cat(CalcError(p1T[n]), CalcError(p1T[n + 1]), CalcError(p1T[n + 2])); };
+
+        auto CalcT = [](sal_Int32* dst, const int* src, int b, int g, int r)
+        {
+            dst[0] += src[b];
+            dst[1] += src[g];
+            dst[2] += src[r];
+        };
+
+        auto Calc1 = [&](int x, int b, int g, int r) { CalcT(p2T + x + 3, FloydError1, b, g, r); };
+        auto Calc3 = [&](int x, int b, int g, int r) { CalcT(p2T + x - 3, FloydError3, b, g, r); };
+        auto Calc5 = [&](int x, int b, int g, int r) { CalcT(p2T + x, FloydError5, b, g, r); };
+        auto Calc7 = [&](int x, int b, int g, int r) { CalcT(p1T + x + 3, FloydError7, b, g, r); };
+
+        Scanline pScanline = pWriteAcc->GetScanline(nYAcc);
+        // Examine first Pixel separately
+        {
+            auto [nBErr, nBC, nGErr, nGC, nRErr, nRC] = CalcErrors(0);
+            Calc1(0, nBErr, nGErr, nRErr);
+            Calc5(0, nBErr, nGErr, nRErr);
+            Calc7(0, nBErr, nGErr, nRErr);
+            pWriteAcc->SetPixelOnData( pScanline, 0, BitmapColor(static_cast<sal_uInt8>(nVCLBLut[ nBC ] + nVCLGLut[nGC ] + nVCLRLut[nRC ])) );
+        }
+        // Get middle Pixels using a loop
+        for ( tools::Long nX = 3, nXAcc = 1; nX < nW2; nX += 3, nXAcc++ )
+        {
+            auto [nBErr, nBC, nGErr, nGC, nRErr, nRC] = CalcErrors(nX);
+            Calc1(nX, nBErr, nGErr, nRErr);
+            Calc3(nX, nBErr, nGErr, nRErr);
+            Calc5(nX, nBErr, nGErr, nRErr);
+            Calc7(nX, nBErr, nGErr, nRErr);
+            pWriteAcc->SetPixelOnData( pScanline, nXAcc, BitmapColor(static_cast<sal_uInt8>(nVCLBLut[ nBC ] + nVCLGLut[nGC ] + nVCLRLut[nRC ])) );
+        }
+        // Treat last Pixel separately
+        {
+            auto [nBErr, nBC, nGErr, nGC, nRErr, nRC] = CalcErrors(nW2);
+            Calc3(nW2, nBErr, nGErr, nRErr);
+            Calc5(nW2, nBErr, nGErr, nRErr);
+            pWriteAcc->SetPixelOnData( pScanline, nWidth1, BitmapColor(static_cast<sal_uInt8>(nVCLBLut[ nBC ] + nVCLGLut[nGC ] + nVCLRLut[nRC ])) );
+        }
+    }
+    pReadAcc.reset();
+    pWriteAcc.reset();
+    const MapMode aMap( maPrefMapMode );
+    const Size aPrefSize( maPrefSize );
+    *this = aNewBmp;
+    maPrefMapMode = aMap;
+    maPrefSize = aPrefSize;
+    return true;
+}
+
+void Bitmap::Vectorize( GDIMetaFile& rMtf, sal_uInt8 cReduce, const Link<tools::Long,void>* pProgress )
+{
+    ImplVectorizer::ImplVectorize( *this, rMtf, cReduce, pProgress );
+}
+
+bool Bitmap::Adjust( short nLuminancePercent, short nContrastPercent,
+                     short nChannelRPercent, short nChannelGPercent, short nChannelBPercent,
+                     double fGamma, bool bInvert, bool msoBrightness )
+{
+    // nothing to do => return quickly
+    if( !nLuminancePercent && !nContrastPercent &&
+        !nChannelRPercent && !nChannelGPercent && !nChannelBPercent &&
+        ( fGamma == 1.0 ) && !bInvert )
+    {
+        return true;
+    }
+
+    BitmapScopedWriteAccess pAcc(*this);
+    if( !pAcc )
+        return false;
+
+    BitmapColor aCol;
+    const tools::Long nW = pAcc->Width();
+    const tools::Long nH = pAcc->Height();
+    std::unique_ptr<sal_uInt8[]> cMapR(new sal_uInt8[ 256 ]);
+    std::unique_ptr<sal_uInt8[]> cMapG(new sal_uInt8[ 256 ]);
+    std::unique_ptr<sal_uInt8[]> cMapB(new sal_uInt8[ 256 ]);
+    double fM, fROff, fGOff, fBOff, fOff;
+
+    // calculate slope
+    if( nContrastPercent >= 0 )
+        fM = 128.0 / ( 128.0 - 1.27 * std::clamp( nContrastPercent, short(0), short(100) ) );
+    else
+        fM = ( 128.0 + 1.27 * std::clamp( nContrastPercent, short(-100), short(0) ) ) / 128.0;
+
+    if(!msoBrightness)
+        // total offset = luminance offset + contrast offset
+        fOff = std::clamp( nLuminancePercent, short(-100), short(100) ) * 2.55 + 128.0 - fM * 128.0;
+    else
+        fOff = std::clamp( nLuminancePercent, short(-100), short(100) ) * 2.55;
+
+    // channel offset = channel offset + total offset
+    fROff = nChannelRPercent * 2.55 + fOff;
+    fGOff = nChannelGPercent * 2.55 + fOff;
+    fBOff = nChannelBPercent * 2.55 + fOff;
+
+    // calculate gamma value
+    fGamma = ( fGamma <= 0.0 || fGamma > 10.0 ) ? 1.0 : ( 1.0 / fGamma );
+    const bool bGamma = ( fGamma != 1.0 );
+
+    // create mapping table
+    for( tools::Long nX = 0; nX < 256; nX++ )
+    {
+        if(!msoBrightness)
+        {
+            cMapR[ nX ] = FRound( std::clamp( nX * fM + fROff, 0.0, 255.0 ) );
+            cMapG[ nX ] = FRound( std::clamp( nX * fM + fGOff, 0.0, 255.0 ) );
+            cMapB[ nX ] = FRound( std::clamp( nX * fM + fBOff, 0.0, 255.0 ) );
+        }
+        else
+        {
+            // LO simply uses (in a somewhat optimized form) "newcolor = (oldcolor-128)*contrast+brightness+128"
+            // as the formula, i.e. contrast first, brightness afterwards. MSOffice, for whatever weird reason,
+            // use neither first, but apparently it applies half of brightness before contrast and half afterwards.
+            cMapR[ nX ] = FRound( std::clamp( (nX+fROff/2-128) * fM + 128 + fROff/2, 0.0, 255.0 ) );
+            cMapG[ nX ] = FRound( std::clamp( (nX+fGOff/2-128) * fM + 128 + fGOff/2, 0.0, 255.0 ) );
+            cMapB[ nX ] = FRound( std::clamp( (nX+fBOff/2-128) * fM + 128 + fBOff/2, 0.0, 255.0 ) );
+        }
+        if( bGamma )
+        {
+            cMapR[ nX ] = GAMMA( cMapR[ nX ], fGamma );
+            cMapG[ nX ] = GAMMA( cMapG[ nX ], fGamma );
+            cMapB[ nX ] = GAMMA( cMapB[ nX ], fGamma );
+        }
+
+        if( bInvert )
+        {
+            cMapR[ nX ] = ~cMapR[ nX ];
+            cMapG[ nX ] = ~cMapG[ nX ];
+            cMapB[ nX ] = ~cMapB[ nX ];
+        }
+    }
+
+    // do modifying
+    if( pAcc->HasPalette() )
+    {
+        BitmapColor aNewCol;
+
+        for( sal_uInt16 i = 0, nCount = pAcc->GetPaletteEntryCount(); i < nCount; i++ )
+        {
+            const BitmapColor& rCol = pAcc->GetPaletteColor( i );
+            aNewCol.SetRed( cMapR[ rCol.GetRed() ] );
+            aNewCol.SetGreen( cMapG[ rCol.GetGreen() ] );
+            aNewCol.SetBlue( cMapB[ rCol.GetBlue() ] );
+            pAcc->SetPaletteColor( i, aNewCol );
+        }
+    }
+    else if( pAcc->GetScanlineFormat() == ScanlineFormat::N24BitTcBgr )
+    {
+        for( tools::Long nY = 0; nY < nH; nY++ )
+        {
+            Scanline pScan = pAcc->GetScanline( nY );
+
+            for( tools::Long nX = 0; nX < nW; nX++ )
+            {
+                *pScan = cMapB[ *pScan ]; pScan++;
+                *pScan = cMapG[ *pScan ]; pScan++;
+                *pScan = cMapR[ *pScan ]; pScan++;
+            }
+        }
+    }
+    else if( pAcc->GetScanlineFormat() == ScanlineFormat::N24BitTcRgb )
+    {
+        for( tools::Long nY = 0; nY < nH; nY++ )
+        {
+            Scanline pScan = pAcc->GetScanline( nY );
+
+            for( tools::Long nX = 0; nX < nW; nX++ )
+            {
+                *pScan = cMapR[ *pScan ]; pScan++;
+                *pScan = cMapG[ *pScan ]; pScan++;
+                *pScan = cMapB[ *pScan ]; pScan++;
+            }
+        }
+    }
+    else
+    {
+        for( tools::Long nY = 0; nY < nH; nY++ )
+        {
+            Scanline pScanline = pAcc->GetScanline(nY);
+            for( tools::Long nX = 0; nX < nW; nX++ )
+            {
+                aCol = pAcc->GetPixelFromData( pScanline, nX );
+                aCol.SetRed( cMapR[ aCol.GetRed() ] );
+                aCol.SetGreen( cMapG[ aCol.GetGreen() ] );
+                aCol.SetBlue( cMapB[ aCol.GetBlue() ] );
+                pAcc->SetPixelOnData( pScanline, nX, aCol );
+            }
+        }
+    }
+
+    pAcc.reset();
+
+    return true;
+}
+
+namespace
+{
+inline sal_uInt8 backBlendAlpha(sal_uInt16 alpha, sal_uInt16 srcCol, sal_uInt16 startCol)
+{
+    const sal_uInt16 nAlpha((alpha * startCol) / 255);
+    if(srcCol > nAlpha)
+    {
+        return static_cast<sal_uInt8>(((srcCol - nAlpha) * 255) / (255 - nAlpha));
+    }
+
+    return 0;
+}
+}
+
+void Bitmap::RemoveBlendedStartColor(
+    const Color& rStartColor,
+    const AlphaMask& rAlphaMask)
+{
+    // no content, done
+    if(IsEmpty())
+        return;
+
+    BitmapScopedWriteAccess pAcc(*this);
+    const tools::Long nHeight(pAcc->Height());
+    const tools::Long nWidth(pAcc->Width());
+
+    // no content, done
+    if(0 == nHeight || 0 == nWidth)
+        return;
+
+    BitmapScopedReadAccess pAlphaAcc(rAlphaMask);
+
+    // inequal sizes of content and alpha, avoid change (maybe assert?)
+    if(pAlphaAcc->Height() != nHeight || pAlphaAcc->Width() != nWidth)
+        return;
+
+    // prepare local values as sal_uInt16 to avoid multiple conversions
+    const sal_uInt16 nStartColRed(rStartColor.GetRed());
+    const sal_uInt16 nStartColGreen(rStartColor.GetGreen());
+    const sal_uInt16 nStartColBlue(rStartColor.GetBlue());
+
+    for (tools::Long y = 0; y < nHeight; ++y)
+    {
+        for (tools::Long x = 0; x < nWidth; ++x)
+        {
+            // get alpha value
+            const sal_uInt8 nAlpha8(pAlphaAcc->GetColor(y, x).GetRed());
+
+            // not or completely transparent, no adaptation needed
+            if(0 == nAlpha8 || 255 == nAlpha8)
+                continue;
+
+            // prepare local value as sal_uInt16 to avoid multiple conversions
+            const sal_uInt16 nAlpha16(static_cast<sal_uInt16>(nAlpha8));
+
+            // get source color
+            BitmapColor aColor(pAcc->GetColor(y, x));
+
+            // modify/blend back source color
+            aColor.SetRed(backBlendAlpha(nAlpha16, static_cast<sal_uInt16>(aColor.GetRed()), nStartColRed));
+            aColor.SetGreen(backBlendAlpha(nAlpha16, static_cast<sal_uInt16>(aColor.GetGreen()), nStartColGreen));
+            aColor.SetBlue(backBlendAlpha(nAlpha16, static_cast<sal_uInt16>(aColor.GetBlue()), nStartColBlue));
+
+            // write result back
+            pAcc->SetPixel(y, x, aColor);
+        }
+    }
+}
+
+const basegfx::SystemDependentDataHolder* Bitmap::accessSystemDependentDataHolder() const
+{
+    if(!mxSalBmp)
+        return nullptr;
+    return mxSalBmp->accessSystemDependentDataHolder();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/bitmapfilter.cxx b/vcl/source/bitmap/bitmapfilter.cxx
new file mode 100644
index 0000000000..63ccd2b130
--- /dev/null
+++ b/vcl/source/bitmap/bitmapfilter.cxx
@@ -0,0 +1,58 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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 <vcl/BitmapFilter.hxx>
+#include <vcl/animate/Animation.hxx>
+
+#include <sal/log.hxx>
+
+BitmapFilter::BitmapFilter() {}
+
+BitmapFilter::~BitmapFilter() {}
+
+bool BitmapFilter::Filter(BitmapEx& rBmpEx, BitmapFilter const& rFilter)
+{
+    BitmapEx aTmpBmpEx(rFilter.execute(rBmpEx));
+
+    if (aTmpBmpEx.IsEmpty())
+    {
+        SAL_WARN("vcl.gdi", "Bitmap filter failed " << typeid(rFilter).name());
+        return false;
+    }
+
+    rBmpEx = aTmpBmpEx;
+    return true;
+}
+
+bool BitmapFilter::Filter(Animation& rAnimation, BitmapFilter const& rFilter)
+{
+    SAL_WARN_IF(rAnimation.IsInAnimation(), "vcl", "Animation modified while it is animated");
+
+    bool bRet = false;
+
+    if (!rAnimation.IsInAnimation() && !rAnimation.Count())
+    {
+        bRet = true;
+
+        std::vector<std::unique_ptr<AnimationFrame>>& aList = rAnimation.GetAnimationFrames();
+        for (size_t i = 0, n = aList.size(); (i < n) && bRet; ++i)
+        {
+            bRet = BitmapFilter::Filter(aList[i]->maBitmapEx, rFilter);
+        }
+
+        BitmapEx aBmpEx(rAnimation.GetBitmapEx());
+        BitmapFilter::Filter(aBmpEx, rFilter);
+        rAnimation.SetBitmapEx(aBmpEx);
+    }
+
+    return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/bitmappaint.cxx b/vcl/source/bitmap/bitmappaint.cxx
new file mode 100644
index 0000000000..cc3674ad31
--- /dev/null
+++ b/vcl/source/bitmap/bitmappaint.cxx
@@ -0,0 +1,1226 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <tools/poly.hxx>
+#include <tools/helpers.hxx>
+
+#include <vcl/bitmap.hxx>
+#include <vcl/alpha.hxx>
+
+#include <vcl/BitmapWriteAccess.hxx>
+#include <salbmp.hxx>
+#include <svdata.hxx>
+#include <salinst.hxx>
+
+#include <algorithm>
+#include <memory>
+
+static BitmapColor UpdatePaletteForNewColor(BitmapScopedWriteAccess& pAcc,
+                                            const sal_uInt16 nActColors,
+                                            const sal_uInt16 nMaxColors, const tools::Long nHeight,
+                                            const tools::Long nWidth,
+                                            const BitmapColor& rWantedColor);
+
+bool Bitmap::Erase(const Color& rFillColor)
+{
+    if (IsEmpty())
+        return true;
+
+    // implementation specific replace
+    std::shared_ptr<SalBitmap> xImpBmp(ImplGetSVData()->mpDefInst->CreateSalBitmap());
+    if (xImpBmp->Create(*mxSalBmp) && xImpBmp->Erase(rFillColor))
+    {
+        ImplSetSalBitmap(xImpBmp);
+        maPrefMapMode = MapMode(MapUnit::MapPixel);
+        maPrefSize = xImpBmp->GetSize();
+        return true;
+    }
+
+    BitmapScopedWriteAccess pWriteAcc(*this);
+    bool bRet = false;
+
+    if (pWriteAcc)
+    {
+        pWriteAcc->Erase(rFillColor);
+        bRet = true;
+    }
+
+    return bRet;
+}
+
+bool Bitmap::Invert()
+{
+    if (!mxSalBmp)
+        return false;
+
+    // try optimised call, much faster on Skia
+    if (mxSalBmp->Invert())
+    {
+        mxSalBmp->InvalidateChecksum();
+        return true;
+    }
+
+    BitmapScopedWriteAccess pWriteAcc(*this);
+    const tools::Long nWidth = pWriteAcc->Width();
+    const tools::Long nHeight = pWriteAcc->Height();
+
+    if (pWriteAcc->HasPalette())
+    {
+        const sal_uInt16 nActColors = pWriteAcc->GetPaletteEntryCount();
+        const sal_uInt16 nMaxColors = 1 << pWriteAcc->GetBitCount();
+
+        if (pWriteAcc->GetPalette().IsGreyPalette8Bit())
+        {
+            for (tools::Long nY = 0; nY < nHeight; nY++)
+            {
+                Scanline pScanline = pWriteAcc->GetScanline(nY);
+                for (tools::Long nX = 0; nX < nWidth; nX++)
+                {
+                    BitmapColor aBmpColor = pWriteAcc->GetPixelFromData(pScanline, nX);
+                    aBmpColor.SetIndex(0xff - aBmpColor.GetIndex());
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aBmpColor);
+                }
+            }
+        }
+        else
+        {
+            for (tools::Long nY = 0; nY < nHeight; nY++)
+            {
+                Scanline pScanline = pWriteAcc->GetScanline(nY);
+                for (tools::Long nX = 0; nX < nWidth; nX++)
+                {
+                    BitmapColor aBmpColor = pWriteAcc->GetPixelFromData(pScanline, nX);
+                    aBmpColor = pWriteAcc->GetPaletteColor(aBmpColor.GetIndex());
+                    aBmpColor.Invert();
+                    BitmapColor aReplace = UpdatePaletteForNewColor(
+                        pWriteAcc, nActColors, nMaxColors, nHeight, nWidth, aBmpColor);
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aReplace);
+                }
+            }
+        }
+    }
+    else
+    {
+        for (tools::Long nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            for (tools::Long nX = 0; nX < nWidth; nX++)
+            {
+                BitmapColor aBmpColor = pWriteAcc->GetPixelFromData(pScanline, nX);
+                aBmpColor.Invert();
+                pWriteAcc->SetPixelOnData(pScanline, nX, aBmpColor);
+            }
+        }
+    }
+    mxSalBmp->InvalidateChecksum();
+
+    return true;
+}
+
+namespace
+{
+// Put each scanline's content horizontally mirrored into the other one.
+// (optimized version accessing pixel values directly).
+template <int bitCount>
+void mirrorScanlines(Scanline scanline1, Scanline scanline2, tools::Long nWidth)
+{
+    constexpr int byteCount = bitCount / 8;
+    Scanline pos1 = scanline1;
+    Scanline pos2 = scanline2 + (nWidth - 1) * byteCount; // last in second scanline
+    sal_uInt8 tmp[byteCount];
+    for (tools::Long i = 0; i < nWidth; ++i)
+    {
+        memcpy(tmp, pos1, byteCount);
+        memcpy(pos1, pos2, byteCount);
+        memcpy(pos2, tmp, byteCount);
+        pos1 += byteCount;
+        pos2 -= byteCount;
+    }
+}
+}
+
+bool Bitmap::Mirror(BmpMirrorFlags nMirrorFlags)
+{
+    bool bHorz(nMirrorFlags & BmpMirrorFlags::Horizontal);
+    bool bVert(nMirrorFlags & BmpMirrorFlags::Vertical);
+    bool bRet = false;
+
+    if (bHorz && !bVert)
+    {
+        BitmapScopedWriteAccess pAcc(*this);
+
+        if (pAcc)
+        {
+            const tools::Long nWidth = pAcc->Width();
+            const tools::Long nHeight = pAcc->Height();
+            const tools::Long nWidth1 = nWidth - 1;
+            const tools::Long nWidth_2 = nWidth / 2;
+            const tools::Long nSecondHalf = nWidth - nWidth_2;
+
+            switch (pAcc->GetBitCount())
+            {
+                // Special-case these, swap the halves of scanlines while mirroring them.
+                case 32:
+                    for (tools::Long nY = 0; nY < nHeight; nY++)
+                        mirrorScanlines<32>(pAcc->GetScanline(nY),
+                                            pAcc->GetScanline(nY) + 4 * nSecondHalf, nWidth_2);
+                    break;
+                case 24:
+                    for (tools::Long nY = 0; nY < nHeight; nY++)
+                        mirrorScanlines<24>(pAcc->GetScanline(nY),
+                                            pAcc->GetScanline(nY) + 3 * nSecondHalf, nWidth_2);
+                    break;
+                case 8:
+                    for (tools::Long nY = 0; nY < nHeight; nY++)
+                        mirrorScanlines<8>(pAcc->GetScanline(nY),
+                                           pAcc->GetScanline(nY) + nSecondHalf, nWidth_2);
+                    break;
+                default:
+                    for (tools::Long nY = 0; nY < nHeight; nY++)
+                    {
+                        Scanline pScanline = pAcc->GetScanline(nY);
+                        for (tools::Long nX = 0, nOther = nWidth1; nX < nWidth_2; nX++, nOther--)
+                        {
+                            const BitmapColor aTemp(pAcc->GetPixelFromData(pScanline, nX));
+
+                            pAcc->SetPixelOnData(pScanline, nX,
+                                                 pAcc->GetPixelFromData(pScanline, nOther));
+                            pAcc->SetPixelOnData(pScanline, nOther, aTemp);
+                        }
+                    }
+            }
+
+            pAcc.reset();
+            bRet = true;
+        }
+    }
+    else if (bVert && !bHorz)
+    {
+        BitmapScopedWriteAccess pAcc(*this);
+
+        if (pAcc)
+        {
+            const tools::Long nScanSize = pAcc->GetScanlineSize();
+            std::unique_ptr<sal_uInt8[]> pBuffer(new sal_uInt8[nScanSize]);
+            const tools::Long nHeight = pAcc->Height();
+            const tools::Long nHeight1 = nHeight - 1;
+            const tools::Long nHeight_2 = nHeight >> 1;
+
+            for (tools::Long nY = 0, nOther = nHeight1; nY < nHeight_2; nY++, nOther--)
+            {
+                memcpy(pBuffer.get(), pAcc->GetScanline(nY), nScanSize);
+                memcpy(pAcc->GetScanline(nY), pAcc->GetScanline(nOther), nScanSize);
+                memcpy(pAcc->GetScanline(nOther), pBuffer.get(), nScanSize);
+            }
+
+            pAcc.reset();
+            bRet = true;
+        }
+    }
+    else if (bHorz && bVert)
+    {
+        BitmapScopedWriteAccess pAcc(*this);
+
+        if (pAcc)
+        {
+            const tools::Long nWidth = pAcc->Width();
+            const tools::Long nWidth1 = nWidth - 1;
+            const tools::Long nHeight = pAcc->Height();
+            tools::Long nHeight_2 = nHeight / 2;
+            const tools::Long nWidth_2 = nWidth / 2;
+            const tools::Long nSecondHalf = nWidth - nWidth_2;
+
+            switch (pAcc->GetBitCount())
+            {
+                case 32:
+                    for (tools::Long nY = 0, nOtherY = nHeight - 1; nY < nHeight_2; nY++, nOtherY--)
+                        mirrorScanlines<32>(pAcc->GetScanline(nY), pAcc->GetScanline(nOtherY),
+                                            nWidth);
+                    if (nHeight & 1)
+                        mirrorScanlines<32>(pAcc->GetScanline(nHeight_2),
+                                            pAcc->GetScanline(nHeight_2) + 4 * nSecondHalf,
+                                            nWidth_2);
+                    break;
+                case 24:
+                    for (tools::Long nY = 0, nOtherY = nHeight - 1; nY < nHeight_2; nY++, nOtherY--)
+                        mirrorScanlines<24>(pAcc->GetScanline(nY), pAcc->GetScanline(nOtherY),
+                                            nWidth);
+                    if (nHeight & 1)
+                        mirrorScanlines<24>(pAcc->GetScanline(nHeight_2),
+                                            pAcc->GetScanline(nHeight_2) + 3 * nSecondHalf,
+                                            nWidth_2);
+                    break;
+                case 8:
+                    for (tools::Long nY = 0, nOtherY = nHeight - 1; nY < nHeight_2; nY++, nOtherY--)
+                        mirrorScanlines<8>(pAcc->GetScanline(nY), pAcc->GetScanline(nOtherY),
+                                           nWidth);
+                    if (nHeight & 1)
+                        mirrorScanlines<8>(pAcc->GetScanline(nHeight_2),
+                                           pAcc->GetScanline(nHeight_2) + nSecondHalf, nWidth_2);
+                    break;
+                default:
+                    for (tools::Long nY = 0, nOtherY = nHeight - 1; nY < nHeight_2; nY++, nOtherY--)
+                    {
+                        Scanline pScanline = pAcc->GetScanline(nY);
+                        Scanline pScanlineOther = pAcc->GetScanline(nOtherY);
+                        for (tools::Long nX = 0, nOtherX = nWidth1; nX < nWidth; nX++, nOtherX--)
+                        {
+                            const BitmapColor aTemp(pAcc->GetPixelFromData(pScanline, nX));
+
+                            pAcc->SetPixelOnData(pScanline, nX,
+                                                 pAcc->GetPixelFromData(pScanlineOther, nOtherX));
+                            pAcc->SetPixelOnData(pScanlineOther, nOtherX, aTemp);
+                        }
+                    }
+
+                    // if necessary, also mirror the middle line horizontally
+                    if (nHeight & 1)
+                    {
+                        Scanline pScanline = pAcc->GetScanline(nHeight_2);
+                        for (tools::Long nX = 0, nOtherX = nWidth1; nX < nWidth_2; nX++, nOtherX--)
+                        {
+                            const BitmapColor aTemp(pAcc->GetPixelFromData(pScanline, nX));
+                            pAcc->SetPixelOnData(pScanline, nX,
+                                                 pAcc->GetPixelFromData(pScanline, nOtherX));
+                            pAcc->SetPixelOnData(pScanline, nOtherX, aTemp);
+                        }
+                    }
+            }
+
+            pAcc.reset();
+            bRet = true;
+        }
+    }
+    else
+        bRet = true;
+
+    return bRet;
+}
+
+bool Bitmap::Rotate(Degree10 nAngle10, const Color& rFillColor)
+{
+    nAngle10 %= 3600_deg10;
+    nAngle10 = (nAngle10 < 0_deg10) ? (Degree10(3599) + nAngle10) : nAngle10;
+
+    if (!nAngle10)
+        return true;
+    if (nAngle10 == 1800_deg10)
+        return Mirror(BmpMirrorFlags::Horizontal | BmpMirrorFlags::Vertical);
+
+    BitmapScopedReadAccess pReadAcc(*this);
+    if (!pReadAcc)
+        return false;
+
+    Bitmap aRotatedBmp;
+    bool bRet = false;
+    const Size aSizePix(GetSizePixel());
+
+    if (nAngle10 == 900_deg10 || nAngle10 == 2700_deg10)
+    {
+        const Size aNewSizePix(aSizePix.Height(), aSizePix.Width());
+        Bitmap aNewBmp(aNewSizePix, getPixelFormat(), &pReadAcc->GetPalette());
+        BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+
+        if (pWriteAcc)
+        {
+            const tools::Long nWidth = aSizePix.Width();
+            const tools::Long nWidth1 = nWidth - 1;
+            const tools::Long nHeight = aSizePix.Height();
+            const tools::Long nHeight1 = nHeight - 1;
+            const tools::Long nNewWidth = aNewSizePix.Width();
+            const tools::Long nNewHeight = aNewSizePix.Height();
+
+            if (nAngle10 == 900_deg10)
+            {
+                for (tools::Long nY = 0, nOtherX = nWidth1; nY < nNewHeight; nY++, nOtherX--)
+                {
+                    Scanline pScanline = pWriteAcc->GetScanline(nY);
+                    for (tools::Long nX = 0, nOtherY = 0; nX < nNewWidth; nX++)
+                    {
+                        pWriteAcc->SetPixelOnData(pScanline, nX,
+                                                  pReadAcc->GetPixel(nOtherY++, nOtherX));
+                    }
+                }
+            }
+            else if (nAngle10 == 2700_deg10)
+            {
+                for (tools::Long nY = 0, nOtherX = 0; nY < nNewHeight; nY++, nOtherX++)
+                {
+                    Scanline pScanline = pWriteAcc->GetScanline(nY);
+                    for (tools::Long nX = 0, nOtherY = nHeight1; nX < nNewWidth; nX++)
+                    {
+                        pWriteAcc->SetPixelOnData(pScanline, nX,
+                                                  pReadAcc->GetPixel(nOtherY--, nOtherX));
+                    }
+                }
+            }
+
+            pWriteAcc.reset();
+        }
+
+        aRotatedBmp = aNewBmp;
+    }
+    else
+    {
+        Point aTmpPoint;
+        tools::Rectangle aTmpRectangle(aTmpPoint, aSizePix);
+        tools::Polygon aPoly(aTmpRectangle);
+        aPoly.Rotate(aTmpPoint, nAngle10);
+
+        tools::Rectangle aNewBound(aPoly.GetBoundRect());
+        const Size aNewSizePix(aNewBound.GetSize());
+        Bitmap aNewBmp(aNewSizePix, getPixelFormat(), &pReadAcc->GetPalette());
+        BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+
+        if (pWriteAcc)
+        {
+            const BitmapColor aFillColor(pWriteAcc->GetBestMatchingColor(rFillColor));
+            const double fCosAngle = cos(toRadians(nAngle10));
+            const double fSinAngle = sin(toRadians(nAngle10));
+            const double fXMin = aNewBound.Left();
+            const double fYMin = aNewBound.Top();
+            const sal_Int32 nWidth = aSizePix.Width();
+            const sal_Int32 nHeight = aSizePix.Height();
+            const sal_Int32 nNewWidth = aNewSizePix.Width();
+            const sal_Int32 nNewHeight = aNewSizePix.Height();
+            // we store alternating values of cos/sin. We do this instead of
+            // separate arrays to improve cache hit.
+            std::unique_ptr<sal_Int32[]> pCosSinX(new sal_Int32[nNewWidth * 2]);
+            std::unique_ptr<sal_Int32[]> pCosSinY(new sal_Int32[nNewHeight * 2]);
+
+            for (sal_Int32 nIdx = 0, nX = 0; nX < nNewWidth; nX++)
+            {
+                const double fTmp = (fXMin + nX) * 64;
+
+                pCosSinX[nIdx++] = std::round(fCosAngle * fTmp);
+                pCosSinX[nIdx++] = std::round(fSinAngle * fTmp);
+            }
+
+            for (sal_Int32 nIdx = 0, nY = 0; nY < nNewHeight; nY++)
+            {
+                const double fTmp = (fYMin + nY) * 64;
+
+                pCosSinY[nIdx++] = std::round(fCosAngle * fTmp);
+                pCosSinY[nIdx++] = std::round(fSinAngle * fTmp);
+            }
+
+            for (sal_Int32 nCosSinYIdx = 0, nY = 0; nY < nNewHeight; nY++)
+            {
+                sal_Int32 nCosY = pCosSinY[nCosSinYIdx++];
+                sal_Int32 nSinY = pCosSinY[nCosSinYIdx++];
+                Scanline pScanline = pWriteAcc->GetScanline(nY);
+
+                for (sal_Int32 nCosSinXIdx = 0, nX = 0; nX < nNewWidth; nX++)
+                {
+                    sal_Int32 nRotX = (pCosSinX[nCosSinXIdx++] - nSinY) >> 6;
+                    sal_Int32 nRotY = (pCosSinX[nCosSinXIdx++] + nCosY) >> 6;
+
+                    if ((nRotX > -1) && (nRotX < nWidth) && (nRotY > -1) && (nRotY < nHeight))
+                    {
+                        pWriteAcc->SetPixelOnData(pScanline, nX, pReadAcc->GetPixel(nRotY, nRotX));
+                    }
+                    else
+                    {
+                        pWriteAcc->SetPixelOnData(pScanline, nX, aFillColor);
+                    }
+                }
+            }
+
+            pWriteAcc.reset();
+        }
+
+        aRotatedBmp = aNewBmp;
+    }
+
+    pReadAcc.reset();
+
+    bRet = !aRotatedBmp.IsEmpty();
+    if (bRet)
+        ReassignWithSize(aRotatedBmp);
+
+    return bRet;
+};
+
+Bitmap Bitmap::CreateMask(const Color& rTransColor) const
+{
+    BitmapScopedReadAccess pReadAcc(*this);
+    if (!pReadAcc)
+        return Bitmap();
+
+    // Historically LO used 1bpp masks, but 8bpp masks are much faster,
+    // better supported by hardware, and the memory savings are not worth
+    // it anymore.
+    // TODO: Possibly remove the 1bpp code later.
+
+    if ((pReadAcc->GetScanlineFormat() == ScanlineFormat::N1BitMsbPal)
+        && pReadAcc->GetBestMatchingColor(COL_WHITE) == pReadAcc->GetBestMatchingColor(rTransColor))
+    {
+        // if we're a 1 bit pixel already, and the transcolor matches the color that would replace it
+        // already, then just return a copy
+        return *this;
+    }
+
+    auto ePixelFormat = vcl::PixelFormat::N8_BPP;
+    Bitmap aNewBmp(GetSizePixel(), ePixelFormat, &Bitmap::GetGreyPalette(256));
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if (!pWriteAcc)
+        return Bitmap();
+
+    const tools::Long nWidth = pReadAcc->Width();
+    const tools::Long nHeight = pReadAcc->Height();
+    const BitmapColor aBlack(pWriteAcc->GetBestMatchingColor(COL_BLACK));
+    const BitmapColor aWhite(pWriteAcc->GetBestMatchingColor(COL_WHITE));
+
+    const BitmapColor aTest(pReadAcc->GetBestMatchingColor(rTransColor));
+
+    if (pWriteAcc->GetScanlineFormat() == pReadAcc->GetScanlineFormat() && aWhite.GetIndex() == 1
+        && (pReadAcc->GetScanlineFormat() == ScanlineFormat::N1BitMsbPal))
+    {
+        for (tools::Long nY = 0; nY < nHeight; ++nY)
+        {
+            Scanline pSrc = pReadAcc->GetScanline(nY);
+            Scanline pDst = pWriteAcc->GetScanline(nY);
+            assert(pWriteAcc->GetScanlineSize() == pReadAcc->GetScanlineSize());
+            const tools::Long nScanlineSize = pWriteAcc->GetScanlineSize();
+            for (tools::Long nX = 0; nX < nScanlineSize; ++nX)
+                pDst[nX] = ~pSrc[nX];
+        }
+    }
+    else if (pReadAcc->GetScanlineFormat() == ScanlineFormat::N8BitPal)
+    {
+        // optimized for 8Bit source palette
+        const sal_uInt8 cTest = aTest.GetIndex();
+
+        for (tools::Long nY = 0; nY < nHeight; ++nY)
+        {
+            Scanline pSrc = pReadAcc->GetScanline(nY);
+            Scanline pDst = pWriteAcc->GetScanline(nY);
+            for (tools::Long nX = 0; nX < nWidth; ++nX)
+            {
+                if (cTest == pSrc[nX])
+                    pDst[nX] = aWhite.GetIndex();
+                else
+                    pDst[nX] = aBlack.GetIndex();
+            }
+        }
+    }
+    else
+    {
+        // not optimized
+        for (tools::Long nY = 0; nY < nHeight; ++nY)
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+            for (tools::Long nX = 0; nX < nWidth; ++nX)
+            {
+                if (aTest == pReadAcc->GetPixelFromData(pScanlineRead, nX))
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aWhite);
+                else
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aBlack);
+            }
+        }
+    }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+
+    aNewBmp.maPrefSize = maPrefSize;
+    aNewBmp.maPrefMapMode = maPrefMapMode;
+
+    return aNewBmp;
+}
+
+Bitmap Bitmap::CreateMask(const Color& rTransColor, sal_uInt8 nTol) const
+{
+    if (nTol == 0)
+        return CreateMask(rTransColor);
+
+    BitmapScopedReadAccess pReadAcc(*this);
+    if (!pReadAcc)
+        return Bitmap();
+
+    // Historically LO used 1bpp masks, but 8bpp masks are much faster,
+    // better supported by hardware, and the memory savings are not worth
+    // it anymore.
+    // TODO: Possibly remove the 1bpp code later.
+
+    auto ePixelFormat = vcl::PixelFormat::N8_BPP;
+    Bitmap aNewBmp(GetSizePixel(), ePixelFormat, &Bitmap::GetGreyPalette(256));
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if (!pWriteAcc)
+        return Bitmap();
+
+    const tools::Long nWidth = pReadAcc->Width();
+    const tools::Long nHeight = pReadAcc->Height();
+    const BitmapColor aBlack(pWriteAcc->GetBestMatchingColor(COL_BLACK));
+    const BitmapColor aWhite(pWriteAcc->GetBestMatchingColor(COL_WHITE));
+
+    BitmapColor aCol;
+    tools::Long nR, nG, nB;
+    const tools::Long nMinR = std::clamp<tools::Long>(rTransColor.GetRed() - nTol, 0, 255);
+    const tools::Long nMaxR = std::clamp<tools::Long>(rTransColor.GetRed() + nTol, 0, 255);
+    const tools::Long nMinG = std::clamp<tools::Long>(rTransColor.GetGreen() - nTol, 0, 255);
+    const tools::Long nMaxG = std::clamp<tools::Long>(rTransColor.GetGreen() + nTol, 0, 255);
+    const tools::Long nMinB = std::clamp<tools::Long>(rTransColor.GetBlue() - nTol, 0, 255);
+    const tools::Long nMaxB = std::clamp<tools::Long>(rTransColor.GetBlue() + nTol, 0, 255);
+
+    if (pReadAcc->HasPalette())
+    {
+        for (tools::Long nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+            for (tools::Long nX = 0; nX < nWidth; nX++)
+            {
+                aCol = pReadAcc->GetPaletteColor(pReadAcc->GetIndexFromData(pScanlineRead, nX));
+                nR = aCol.GetRed();
+                nG = aCol.GetGreen();
+                nB = aCol.GetBlue();
+
+                if (nMinR <= nR && nMaxR >= nR && nMinG <= nG && nMaxG >= nG && nMinB <= nB
+                    && nMaxB >= nB)
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aWhite);
+                }
+                else
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aBlack);
+                }
+            }
+        }
+    }
+    else
+    {
+        for (tools::Long nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+            for (tools::Long nX = 0; nX < nWidth; nX++)
+            {
+                aCol = pReadAcc->GetPixelFromData(pScanlineRead, nX);
+                nR = aCol.GetRed();
+                nG = aCol.GetGreen();
+                nB = aCol.GetBlue();
+
+                if (nMinR <= nR && nMaxR >= nR && nMinG <= nG && nMaxG >= nG && nMinB <= nB
+                    && nMaxB >= nB)
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aWhite);
+                }
+                else
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aBlack);
+                }
+            }
+        }
+    }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+
+    aNewBmp.maPrefSize = maPrefSize;
+    aNewBmp.maPrefMapMode = maPrefMapMode;
+
+    return aNewBmp;
+}
+
+AlphaMask Bitmap::CreateAlphaMask(const Color& rTransColor) const
+{
+    BitmapScopedReadAccess pReadAcc(*this);
+    if (!pReadAcc)
+        return AlphaMask();
+
+    // Historically LO used 1bpp masks, but 8bpp masks are much faster,
+    // better supported by hardware, and the memory savings are not worth
+    // it anymore.
+
+    if ((pReadAcc->GetScanlineFormat() == ScanlineFormat::N1BitMsbPal)
+        && pReadAcc->GetBestMatchingColor(COL_ALPHA_TRANSPARENT)
+               == pReadAcc->GetBestMatchingColor(rTransColor))
+    {
+        // if we're a 1 bit pixel already, and the transcolor matches the color that would replace it
+        // already, then just return a copy
+        return AlphaMask(*this);
+    }
+
+    AlphaMask aNewBmp(GetSizePixel());
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if (!pWriteAcc)
+        return AlphaMask();
+
+    const tools::Long nWidth = pReadAcc->Width();
+    const tools::Long nHeight = pReadAcc->Height();
+    const BitmapColor aOpaqueColor(pWriteAcc->GetBestMatchingColor(COL_ALPHA_OPAQUE));
+    const BitmapColor aTransparentColor(pWriteAcc->GetBestMatchingColor(COL_ALPHA_TRANSPARENT));
+
+    const BitmapColor aTest(pReadAcc->GetBestMatchingColor(rTransColor));
+
+    if (pReadAcc->GetScanlineFormat() == ScanlineFormat::N8BitPal)
+    {
+        // optimized for 8Bit source palette
+        const sal_uInt8 cTest = aTest.GetIndex();
+
+        for (tools::Long nY = 0; nY < nHeight; ++nY)
+        {
+            Scanline pSrc = pReadAcc->GetScanline(nY);
+            Scanline pDst = pWriteAcc->GetScanline(nY);
+            for (tools::Long nX = 0; nX < nWidth; ++nX)
+            {
+                if (cTest == pSrc[nX])
+                    pDst[nX] = aTransparentColor.GetIndex();
+                else
+                    pDst[nX] = aOpaqueColor.GetIndex();
+            }
+        }
+    }
+    else
+    {
+        // not optimized
+        for (tools::Long nY = 0; nY < nHeight; ++nY)
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+            for (tools::Long nX = 0; nX < nWidth; ++nX)
+            {
+                if (aTest == pReadAcc->GetPixelFromData(pScanlineRead, nX))
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aTransparentColor);
+                else
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aOpaqueColor);
+            }
+        }
+    }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+
+    aNewBmp.SetPrefSize(maPrefSize);
+    aNewBmp.SetPrefMapMode(maPrefMapMode);
+
+    return aNewBmp;
+}
+
+AlphaMask Bitmap::CreateAlphaMask(const Color& rTransColor, sal_uInt8 nTol) const
+{
+    if (nTol == 0)
+        return CreateAlphaMask(rTransColor);
+
+    BitmapScopedReadAccess pReadAcc(*this);
+    if (!pReadAcc)
+        return AlphaMask();
+
+    // Historically LO used 1bpp masks, but 8bpp masks are much faster,
+    // better supported by hardware, and the memory savings are not worth
+    // it anymore.
+    // TODO: Possibly remove the 1bpp code later.
+
+    AlphaMask aNewBmp(GetSizePixel());
+    BitmapScopedWriteAccess pWriteAcc(aNewBmp);
+    if (!pWriteAcc)
+        return AlphaMask();
+
+    const tools::Long nWidth = pReadAcc->Width();
+    const tools::Long nHeight = pReadAcc->Height();
+    const BitmapColor aOpaqueColor(pWriteAcc->GetBestMatchingColor(COL_ALPHA_OPAQUE));
+    const BitmapColor aTransparentColor(pWriteAcc->GetBestMatchingColor(COL_ALPHA_TRANSPARENT));
+
+    BitmapColor aCol;
+    tools::Long nR, nG, nB;
+    const tools::Long nMinR = std::clamp<tools::Long>(rTransColor.GetRed() - nTol, 0, 255);
+    const tools::Long nMaxR = std::clamp<tools::Long>(rTransColor.GetRed() + nTol, 0, 255);
+    const tools::Long nMinG = std::clamp<tools::Long>(rTransColor.GetGreen() - nTol, 0, 255);
+    const tools::Long nMaxG = std::clamp<tools::Long>(rTransColor.GetGreen() + nTol, 0, 255);
+    const tools::Long nMinB = std::clamp<tools::Long>(rTransColor.GetBlue() - nTol, 0, 255);
+    const tools::Long nMaxB = std::clamp<tools::Long>(rTransColor.GetBlue() + nTol, 0, 255);
+
+    if (pReadAcc->HasPalette())
+    {
+        for (tools::Long nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+            for (tools::Long nX = 0; nX < nWidth; nX++)
+            {
+                aCol = pReadAcc->GetPaletteColor(pReadAcc->GetIndexFromData(pScanlineRead, nX));
+                nR = aCol.GetRed();
+                nG = aCol.GetGreen();
+                nB = aCol.GetBlue();
+
+                if (nMinR <= nR && nMaxR >= nR && nMinG <= nG && nMaxG >= nG && nMinB <= nB
+                    && nMaxB >= nB)
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aTransparentColor);
+                }
+                else
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aOpaqueColor);
+                }
+            }
+        }
+    }
+    else
+    {
+        for (tools::Long nY = 0; nY < nHeight; nY++)
+        {
+            Scanline pScanline = pWriteAcc->GetScanline(nY);
+            Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+            for (tools::Long nX = 0; nX < nWidth; nX++)
+            {
+                aCol = pReadAcc->GetPixelFromData(pScanlineRead, nX);
+                nR = aCol.GetRed();
+                nG = aCol.GetGreen();
+                nB = aCol.GetBlue();
+
+                if (nMinR <= nR && nMaxR >= nR && nMinG <= nG && nMaxG >= nG && nMinB <= nB
+                    && nMaxB >= nB)
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aTransparentColor);
+                }
+                else
+                {
+                    pWriteAcc->SetPixelOnData(pScanline, nX, aOpaqueColor);
+                }
+            }
+        }
+    }
+
+    pWriteAcc.reset();
+    pReadAcc.reset();
+
+    aNewBmp.SetPrefSize(maPrefSize);
+    aNewBmp.SetPrefMapMode(maPrefMapMode);
+
+    return aNewBmp;
+}
+
+vcl::Region Bitmap::CreateRegion(const Color& rColor, const tools::Rectangle& rRect) const
+{
+    tools::Rectangle aRect(rRect);
+    BitmapScopedReadAccess pReadAcc(*this);
+
+    aRect.Intersection(tools::Rectangle(Point(), GetSizePixel()));
+    aRect.Normalize();
+
+    if (!pReadAcc)
+        return vcl::Region(aRect);
+
+    vcl::Region aRegion;
+    const tools::Long nLeft = aRect.Left();
+    const tools::Long nTop = aRect.Top();
+    const tools::Long nRight = aRect.Right();
+    const tools::Long nBottom = aRect.Bottom();
+    const BitmapColor aMatch(pReadAcc->GetBestMatchingColor(rColor));
+
+    std::vector<tools::Long> aLine;
+    tools::Long nYStart(nTop);
+    tools::Long nY(nTop);
+
+    for (; nY <= nBottom; nY++)
+    {
+        std::vector<tools::Long> aNewLine;
+        tools::Long nX(nLeft);
+        Scanline pScanlineRead = pReadAcc->GetScanline(nY);
+
+        for (; nX <= nRight;)
+        {
+            while ((nX <= nRight) && (aMatch != pReadAcc->GetPixelFromData(pScanlineRead, nX)))
+                nX++;
+
+            if (nX <= nRight)
+            {
+                aNewLine.push_back(nX);
+
+                while ((nX <= nRight) && (aMatch == pReadAcc->GetPixelFromData(pScanlineRead, nX)))
+                {
+                    nX++;
+                }
+
+                aNewLine.push_back(nX - 1);
+            }
+        }
+
+        if (aNewLine != aLine)
+        {
+            // need to write aLine, it's different from the next line
+            if (!aLine.empty())
+            {
+                tools::Rectangle aSubRect;
+
+                // enter y values and proceed ystart
+                aSubRect.SetTop(nYStart);
+                aSubRect.SetBottom(nY ? nY - 1 : 0);
+
+                for (size_t a(0); a < aLine.size();)
+                {
+                    aSubRect.SetLeft(aLine[a++]);
+                    aSubRect.SetRight(aLine[a++]);
+                    aRegion.Union(aSubRect);
+                }
+            }
+
+            // copy line as new line
+            aLine = aNewLine;
+            nYStart = nY;
+        }
+    }
+
+    // write last line if used
+    if (!aLine.empty())
+    {
+        tools::Rectangle aSubRect;
+
+        // enter y values
+        aSubRect.SetTop(nYStart);
+        aSubRect.SetBottom(nY ? nY - 1 : 0);
+
+        for (size_t a(0); a < aLine.size();)
+        {
+            aSubRect.SetLeft(aLine[a++]);
+            aSubRect.SetRight(aLine[a++]);
+            aRegion.Union(aSubRect);
+        }
+    }
+
+    pReadAcc.reset();
+
+    return aRegion;
+}
+
+bool Bitmap::ReplaceMask(const AlphaMask& rMask, const Color& rReplaceColor)
+{
+    BitmapScopedReadAccess pMaskAcc(rMask);
+    BitmapScopedWriteAccess pAcc(*this);
+
+    if (!pMaskAcc || !pAcc)
+        return false;
+
+    const tools::Long nWidth = std::min(pMaskAcc->Width(), pAcc->Width());
+    const tools::Long nHeight = std::min(pMaskAcc->Height(), pAcc->Height());
+    const BitmapColor aMaskWhite(pMaskAcc->GetBestMatchingColor(COL_WHITE));
+    BitmapColor aReplace;
+
+    if (pAcc->HasPalette())
+    {
+        const sal_uInt16 nActColors = pAcc->GetPaletteEntryCount();
+        const sal_uInt16 nMaxColors = 1 << pAcc->GetBitCount();
+
+        aReplace = UpdatePaletteForNewColor(pAcc, nActColors, nMaxColors, nHeight, nWidth,
+                                            BitmapColor(rReplaceColor));
+    }
+    else
+        aReplace = rReplaceColor;
+
+    for (tools::Long nY = 0; nY < nHeight; nY++)
+    {
+        Scanline pScanline = pAcc->GetScanline(nY);
+        Scanline pScanlineMask = pMaskAcc->GetScanline(nY);
+        for (tools::Long nX = 0; nX < nWidth; nX++)
+        {
+            if (pMaskAcc->GetPixelFromData(pScanlineMask, nX) == aMaskWhite)
+                pAcc->SetPixelOnData(pScanline, nX, aReplace);
+        }
+    }
+
+    return true;
+}
+
+bool Bitmap::Replace(const AlphaMask& rAlpha, const Color& rMergeColor)
+{
+    Bitmap aNewBmp(GetSizePixel(), vcl::PixelFormat::N24_BPP);
+    BitmapScopedReadAccess pAcc(*this);
+    BitmapScopedReadAccess pAlphaAcc(rAlpha);
+    BitmapScopedWriteAccess pNewAcc(aNewBmp);
+
+    if (!pAcc || !pAlphaAcc || !pNewAcc)
+        return false;
+
+    BitmapColor aCol;
+    const tools::Long nWidth = std::min(pAlphaAcc->Width(), pAcc->Width());
+    const tools::Long nHeight = std::min(pAlphaAcc->Height(), pAcc->Height());
+
+    for (tools::Long nY = 0; nY < nHeight; nY++)
+    {
+        Scanline pScanline = pNewAcc->GetScanline(nY);
+        Scanline pScanlineAlpha = pAlphaAcc->GetScanline(nY);
+        for (tools::Long nX = 0; nX < nWidth; nX++)
+        {
+            aCol = pAcc->GetColor(nY, nX);
+            aCol.Merge(rMergeColor, pAlphaAcc->GetIndexFromData(pScanlineAlpha, nX));
+            pNewAcc->SetPixelOnData(pScanline, nX, aCol);
+        }
+    }
+
+    pAcc.reset();
+    pAlphaAcc.reset();
+    pNewAcc.reset();
+
+    const MapMode aMap(maPrefMapMode);
+    const Size aSize(maPrefSize);
+
+    *this = aNewBmp;
+
+    maPrefMapMode = aMap;
+    maPrefSize = aSize;
+
+    return true;
+}
+
+bool Bitmap::Replace(const Color& rSearchColor, const Color& rReplaceColor, sal_uInt8 nTol)
+{
+    if (mxSalBmp)
+    {
+        // implementation specific replace
+        std::shared_ptr<SalBitmap> xImpBmp(ImplGetSVData()->mpDefInst->CreateSalBitmap());
+        if (xImpBmp->Create(*mxSalBmp) && xImpBmp->Replace(rSearchColor, rReplaceColor, nTol))
+        {
+            ImplSetSalBitmap(xImpBmp);
+            maPrefMapMode = MapMode(MapUnit::MapPixel);
+            maPrefSize = xImpBmp->GetSize();
+            return true;
+        }
+    }
+
+    BitmapScopedWriteAccess pAcc(*this);
+    if (!pAcc)
+        return false;
+
+    const tools::Long nMinR = std::clamp<tools::Long>(rSearchColor.GetRed() - nTol, 0, 255);
+    const tools::Long nMaxR = std::clamp<tools::Long>(rSearchColor.GetRed() + nTol, 0, 255);
+    const tools::Long nMinG = std::clamp<tools::Long>(rSearchColor.GetGreen() - nTol, 0, 255);
+    const tools::Long nMaxG = std::clamp<tools::Long>(rSearchColor.GetGreen() + nTol, 0, 255);
+    const tools::Long nMinB = std::clamp<tools::Long>(rSearchColor.GetBlue() - nTol, 0, 255);
+    const tools::Long nMaxB = std::clamp<tools::Long>(rSearchColor.GetBlue() + nTol, 0, 255);
+
+    if (pAcc->HasPalette())
+    {
+        for (sal_uInt16 i = 0, nPalCount = pAcc->GetPaletteEntryCount(); i < nPalCount; i++)
+        {
+            const BitmapColor& rCol = pAcc->GetPaletteColor(i);
+
+            if (nMinR <= rCol.GetRed() && nMaxR >= rCol.GetRed() && nMinG <= rCol.GetGreen()
+                && nMaxG >= rCol.GetGreen() && nMinB <= rCol.GetBlue() && nMaxB >= rCol.GetBlue())
+            {
+                pAcc->SetPaletteColor(i, rReplaceColor);
+            }
+        }
+    }
+    else
+    {
+        BitmapColor aCol;
+        const BitmapColor aReplace(pAcc->GetBestMatchingColor(rReplaceColor));
+
+        for (tools::Long nY = 0, nHeight = pAcc->Height(); nY < nHeight; nY++)
+        {
+            Scanline pScanline = pAcc->GetScanline(nY);
+            for (tools::Long nX = 0, nWidth = pAcc->Width(); nX < nWidth; nX++)
+            {
+                aCol = pAcc->GetPixelFromData(pScanline, nX);
+
+                if (nMinR <= aCol.GetRed() && nMaxR >= aCol.GetRed() && nMinG <= aCol.GetGreen()
+                    && nMaxG >= aCol.GetGreen() && nMinB <= aCol.GetBlue()
+                    && nMaxB >= aCol.GetBlue())
+                {
+                    pAcc->SetPixelOnData(pScanline, nX, aReplace);
+                }
+            }
+        }
+    }
+
+    pAcc.reset();
+
+    return true;
+}
+
+bool Bitmap::Replace(const Color* pSearchColors, const Color* pReplaceColors, size_t nColorCount,
+                     sal_uInt8 const* pTols)
+{
+    BitmapScopedWriteAccess pAcc(*this);
+    if (!pAcc)
+        return false;
+
+    std::vector<sal_uInt8> aMinR(nColorCount);
+    std::vector<sal_uInt8> aMaxR(nColorCount);
+    std::vector<sal_uInt8> aMinG(nColorCount);
+    std::vector<sal_uInt8> aMaxG(nColorCount);
+    std::vector<sal_uInt8> aMinB(nColorCount);
+    std::vector<sal_uInt8> aMaxB(nColorCount);
+
+    if (pTols)
+    {
+        for (size_t i = 0; i < nColorCount; ++i)
+        {
+            const Color& rCol = pSearchColors[i];
+            const sal_uInt8 nTol = pTols[i];
+
+            aMinR[i] = std::clamp(rCol.GetRed() - nTol, 0, 255);
+            aMaxR[i] = std::clamp(rCol.GetRed() + nTol, 0, 255);
+            aMinG[i] = std::clamp(rCol.GetGreen() - nTol, 0, 255);
+            aMaxG[i] = std::clamp(rCol.GetGreen() + nTol, 0, 255);
+            aMinB[i] = std::clamp(rCol.GetBlue() - nTol, 0, 255);
+            aMaxB[i] = std::clamp(rCol.GetBlue() + nTol, 0, 255);
+        }
+    }
+    else
+    {
+        for (size_t i = 0; i < nColorCount; ++i)
+        {
+            const Color& rCol = pSearchColors[i];
+
+            aMinR[i] = rCol.GetRed();
+            aMaxR[i] = rCol.GetRed();
+            aMinG[i] = rCol.GetGreen();
+            aMaxG[i] = rCol.GetGreen();
+            aMinB[i] = rCol.GetBlue();
+            aMaxB[i] = rCol.GetBlue();
+        }
+    }
+
+    if (pAcc->HasPalette())
+    {
+        for (sal_uInt16 nEntry = 0, nPalCount = pAcc->GetPaletteEntryCount(); nEntry < nPalCount;
+             nEntry++)
+        {
+            const BitmapColor& rCol = pAcc->GetPaletteColor(nEntry);
+
+            for (size_t i = 0; i < nColorCount; ++i)
+            {
+                if (aMinR[i] <= rCol.GetRed() && aMaxR[i] >= rCol.GetRed()
+                    && aMinG[i] <= rCol.GetGreen() && aMaxG[i] >= rCol.GetGreen()
+                    && aMinB[i] <= rCol.GetBlue() && aMaxB[i] >= rCol.GetBlue())
+                {
+                    pAcc->SetPaletteColor(nEntry, pReplaceColors[i]);
+                    break;
+                }
+            }
+        }
+    }
+    else
+    {
+        std::vector<BitmapColor> aReplaces(nColorCount);
+
+        for (size_t i = 0; i < nColorCount; ++i)
+            aReplaces[i] = pAcc->GetBestMatchingColor(pReplaceColors[i]);
+
+        for (tools::Long nY = 0, nHeight = pAcc->Height(); nY < nHeight; nY++)
+        {
+            Scanline pScanline = pAcc->GetScanline(nY);
+            for (tools::Long nX = 0, nWidth = pAcc->Width(); nX < nWidth; nX++)
+            {
+                BitmapColor aCol = pAcc->GetPixelFromData(pScanline, nX);
+
+                for (size_t i = 0; i < nColorCount; ++i)
+                {
+                    if (aMinR[i] <= aCol.GetRed() && aMaxR[i] >= aCol.GetRed()
+                        && aMinG[i] <= aCol.GetGreen() && aMaxG[i] >= aCol.GetGreen()
+                        && aMinB[i] <= aCol.GetBlue() && aMaxB[i] >= aCol.GetBlue())
+                    {
+                        pAcc->SetPixelOnData(pScanline, nX, aReplaces[i]);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    pAcc.reset();
+
+    return true;
+}
+
+// TODO: Have a look at OutputDevice::ImplDrawAlpha() for some
+// optimizations. Might even consolidate the code here and there.
+bool Bitmap::Blend(const AlphaMask& rAlpha, const Color& rBackgroundColor)
+{
+    // Convert to a truecolor bitmap, if we're a paletted one. There's room for tradeoff decision here,
+    // maybe later for an overload (or a flag)
+    if (vcl::isPalettePixelFormat(getPixelFormat()))
+        Convert(BmpConversion::N24Bit);
+
+    BitmapScopedReadAccess pAlphaAcc(rAlpha);
+
+    BitmapScopedWriteAccess pAcc(*this);
+
+    if (!pAlphaAcc || !pAcc)
+        return false;
+
+    const tools::Long nWidth = std::min(pAlphaAcc->Width(), pAcc->Width());
+    const tools::Long nHeight = std::min(pAlphaAcc->Height(), pAcc->Height());
+
+    for (tools::Long nY = 0; nY < nHeight; ++nY)
+    {
+        Scanline pScanline = pAcc->GetScanline(nY);
+        Scanline pScanlineAlpha = pAlphaAcc->GetScanline(nY);
+        for (tools::Long nX = 0; nX < nWidth; ++nX)
+        {
+            BitmapColor aBmpColor = pAcc->GetPixelFromData(pScanline, nX);
+            aBmpColor.Merge(rBackgroundColor, pAlphaAcc->GetIndexFromData(pScanlineAlpha, nX));
+            pAcc->SetPixelOnData(pScanline, nX, aBmpColor);
+        }
+    }
+
+    return true;
+}
+
+static BitmapColor UpdatePaletteForNewColor(BitmapScopedWriteAccess& pAcc,
+                                            const sal_uInt16 nActColors,
+                                            const sal_uInt16 nMaxColors, const tools::Long nHeight,
+                                            const tools::Long nWidth,
+                                            const BitmapColor& rWantedColor)
+{
+    // default to the nearest color
+    sal_uInt16 aReplacePalIndex = pAcc->GetMatchingPaletteIndex(rWantedColor);
+    if (aReplacePalIndex != SAL_MAX_UINT16)
+        return BitmapColor(static_cast<sal_uInt8>(aReplacePalIndex));
+
+    // for paletted images without a matching palette entry
+
+    // if the palette has empty entries use the last one
+    if (nActColors < nMaxColors)
+    {
+        pAcc->SetPaletteEntryCount(nActColors + 1);
+        pAcc->SetPaletteColor(nActColors, rWantedColor);
+        return BitmapColor(static_cast<sal_uInt8>(nActColors));
+    }
+
+    // look for an unused palette entry (NOTE: expensive!)
+    std::unique_ptr<bool[]> pFlags(new bool[nMaxColors]);
+
+    // Set all entries to false
+    std::fill(pFlags.get(), pFlags.get() + nMaxColors, false);
+
+    for (tools::Long nY = 0; nY < nHeight; nY++)
+    {
+        Scanline pScanline = pAcc->GetScanline(nY);
+        for (tools::Long nX = 0; nX < nWidth; nX++)
+            pFlags[pAcc->GetIndexFromData(pScanline, nX)] = true;
+    }
+
+    for (sal_uInt16 i = 0; i < nMaxColors; i++)
+    {
+        // Hurray, we do have an unused entry
+        if (!pFlags[i])
+        {
+            pAcc->SetPaletteColor(i, rWantedColor);
+            return BitmapColor(static_cast<sal_uInt8>(i));
+        }
+    }
+    assert(false && "found nothing");
+    return BitmapColor(0);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/bitmappalette.cxx b/vcl/source/bitmap/bitmappalette.cxx
new file mode 100644
index 0000000000..43eae34754
--- /dev/null
+++ b/vcl/source/bitmap/bitmappalette.cxx
@@ -0,0 +1,242 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <config_features.h>
+
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+#include <rtl/crc.h>
+#include <tools/helpers.hxx>
+
+#include <vcl/BitmapPalette.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/outdev.hxx>
+
+#include <svdata.hxx>
+#include <salinst.hxx>
+
+class ImplBitmapPalette
+{
+public:
+    ImplBitmapPalette(std::initializer_list<BitmapColor> aBitmapColor)
+        : maBitmapColor(aBitmapColor)
+    {
+    }
+    ImplBitmapPalette(const BitmapColor* first, const BitmapColor* last)
+        : maBitmapColor(first, last)
+    {
+    }
+    ImplBitmapPalette() {}
+    ImplBitmapPalette(sal_uInt16 nCount)
+        : maBitmapColor(nCount)
+    {
+    }
+    std::vector<BitmapColor>& GetBitmapData() { return maBitmapColor; }
+    const std::vector<BitmapColor>& GetBitmapData() const { return maBitmapColor; }
+    bool operator==(const ImplBitmapPalette& rBitmapPalette) const
+    {
+        return maBitmapColor == rBitmapPalette.maBitmapColor;
+    }
+
+private:
+    std::vector<BitmapColor> maBitmapColor;
+};
+
+namespace
+{
+BitmapPalette::ImplType& GetGlobalDefault()
+{
+    static BitmapPalette::ImplType gDefault;
+    return gDefault;
+}
+}
+
+BitmapPalette::BitmapPalette()
+    : mpImpl(GetGlobalDefault())
+{
+}
+
+BitmapPalette::BitmapPalette(const BitmapPalette& rOther)
+    : mpImpl(rOther.mpImpl)
+{
+}
+
+BitmapPalette::BitmapPalette(BitmapPalette&& rOther) noexcept
+    : mpImpl(std::move(rOther.mpImpl))
+{
+}
+
+BitmapPalette::BitmapPalette(std::initializer_list<BitmapColor> aBitmapColor)
+    : mpImpl(aBitmapColor)
+{
+}
+
+BitmapPalette::BitmapPalette(const BitmapColor* first, const BitmapColor* last)
+    : mpImpl({ first, last })
+{
+}
+
+BitmapPalette::BitmapPalette(sal_uInt16 nCount)
+    : mpImpl(nCount)
+{
+}
+
+BitmapPalette::~BitmapPalette() {}
+
+BitmapPalette& BitmapPalette::operator=(const BitmapPalette& rOther)
+{
+    mpImpl = rOther.mpImpl;
+    return *this;
+}
+
+BitmapPalette& BitmapPalette::operator=(BitmapPalette&& rOther) noexcept
+{
+    mpImpl = std::move(rOther.mpImpl);
+    return *this;
+}
+
+const BitmapColor* BitmapPalette::ImplGetColorBuffer() const
+{
+    return mpImpl->GetBitmapData().data();
+}
+
+BitmapColor* BitmapPalette::ImplGetColorBuffer() { return mpImpl->GetBitmapData().data(); }
+
+BitmapChecksum BitmapPalette::GetChecksum() const
+{
+    auto const& rBitmapData = mpImpl->GetBitmapData();
+    return rtl_crc32(0, rBitmapData.data(), rBitmapData.size() * sizeof(BitmapColor));
+}
+
+bool BitmapPalette::operator==(const BitmapPalette& rOther) const
+{
+    return mpImpl == rOther.mpImpl;
+}
+
+bool BitmapPalette::operator!() const { return mpImpl->GetBitmapData().empty(); }
+
+sal_uInt16 BitmapPalette::GetEntryCount() const { return mpImpl->GetBitmapData().size(); }
+
+void BitmapPalette::SetEntryCount(sal_uInt16 nCount) { mpImpl->GetBitmapData().resize(nCount); }
+
+const BitmapColor& BitmapPalette::operator[](sal_uInt16 nIndex) const
+{
+    assert(nIndex < mpImpl->GetBitmapData().size() && "Palette index is out of range");
+    return mpImpl->GetBitmapData()[nIndex];
+}
+
+BitmapColor& BitmapPalette::operator[](sal_uInt16 nIndex)
+{
+    assert(nIndex < mpImpl->GetBitmapData().size() && "Palette index is out of range");
+    return mpImpl->GetBitmapData()[nIndex];
+}
+
+/// Returns the BitmapColor (i.e. palette index) that is either an exact match
+/// of the required color, or failing that, the entry that is the closest i.e. least error
+/// as measured by Color::GetColorError.
+sal_uInt16 BitmapPalette::GetBestIndex(const BitmapColor& rCol) const
+{
+    auto const& rBitmapColor = mpImpl->GetBitmapData();
+    sal_uInt16 nRetIndex = 0;
+
+    if (!rBitmapColor.empty())
+    {
+        for (size_t j = 0; j < rBitmapColor.size(); ++j)
+        {
+            if (rCol == rBitmapColor[j])
+            {
+                return j;
+            }
+        }
+
+        sal_uInt16 nLastErr = SAL_MAX_UINT16;
+        for (size_t i = 0; i < rBitmapColor.size(); ++i)
+        {
+            const sal_uInt16 nActErr = rCol.GetColorError(rBitmapColor[i]);
+            if (nActErr < nLastErr)
+            {
+                nLastErr = nActErr;
+                nRetIndex = i;
+            }
+        }
+    }
+
+    return nRetIndex;
+}
+
+/// Returns the BitmapColor (i.e. palette index) that is an exact match
+/// of the required color. Returns SAL_MAX_UINT16 if nothing found.
+sal_uInt16 BitmapPalette::GetMatchingIndex(const BitmapColor& rCol) const
+{
+    auto const& rBitmapColor = mpImpl->GetBitmapData();
+
+    for (size_t j = 0; j < rBitmapColor.size(); ++j)
+    {
+        if (rCol == rBitmapColor[j])
+        {
+            return j;
+        }
+    }
+
+    return SAL_MAX_UINT16;
+}
+
+bool BitmapPalette::IsGreyPaletteAny() const
+{
+    auto const& rBitmapColor = mpImpl->GetBitmapData();
+    const int nEntryCount = GetEntryCount();
+    if (!nEntryCount) // NOTE: an empty palette means 1:1 mapping
+        return true;
+    // See above: only certain entry values will result in a valid call to GetGreyPalette
+    if (nEntryCount == 2 || nEntryCount == 4 || nEntryCount == 16 || nEntryCount == 256)
+    {
+        const BitmapPalette& rGreyPalette = Bitmap::GetGreyPalette(nEntryCount);
+        if (rGreyPalette == *this)
+            return true;
+    }
+
+    bool bRet = false;
+    // TODO: is it worth to compare the entries for the general case?
+    if (nEntryCount == 2)
+    {
+        const BitmapColor& rCol0(rBitmapColor[0]);
+        const BitmapColor& rCol1(rBitmapColor[1]);
+        bRet = rCol0.GetRed() == rCol0.GetGreen() && rCol0.GetRed() == rCol0.GetBlue()
+               && rCol1.GetRed() == rCol1.GetGreen() && rCol1.GetRed() == rCol1.GetBlue();
+    }
+    return bRet;
+}
+
+bool BitmapPalette::IsGreyPalette8Bit() const
+{
+    auto const& rBitmapColor = mpImpl->GetBitmapData();
+    const int nEntryCount = GetEntryCount();
+    if (!nEntryCount) // NOTE: an empty palette means 1:1 mapping
+        return true;
+    if (nEntryCount != 256)
+        return false;
+    for (sal_uInt16 i = 0; i < 256; ++i)
+    {
+        if (rBitmapColor[i] != BitmapColor(i, i, i))
+            return false;
+    }
+    return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/bmpfast.cxx b/vcl/source/bitmap/bmpfast.cxx
new file mode 100644
index 0000000000..53de074adc
--- /dev/null
+++ b/vcl/source/bitmap/bmpfast.cxx
@@ -0,0 +1,823 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <vcl/salgtype.hxx>
+
+#include <vcl/BitmapWriteAccess.hxx>
+#include <bitmap/bmpfast.hxx>
+
+#include <sal/log.hxx>
+
+typedef unsigned char PIXBYTE;
+
+namespace {
+
+class BasePixelPtr
+{
+public:
+    explicit BasePixelPtr( PIXBYTE* p = nullptr ) : mpPixel( p ) {}
+    void    SetRawPtr( PIXBYTE* pRawPtr )               { mpPixel = pRawPtr; }
+    void    AddByteOffset( int nByteOffset )            { mpPixel += nByteOffset; }
+
+protected:
+   PIXBYTE* mpPixel;
+};
+
+template <ScanlineFormat PIXFMT>
+class TrueColorPixelPtr : public BasePixelPtr
+{
+public:
+    PIXBYTE GetRed() const;
+    PIXBYTE GetGreen() const;
+    PIXBYTE GetBlue() const;
+    PIXBYTE GetAlpha() const;
+
+    void    SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const;
+    void    SetAlpha( PIXBYTE a ) const;
+};
+
+// template specializations for truecolor pixel formats
+template <>
+class TrueColorPixelPtr<ScanlineFormat::N24BitTcRgb> : public BasePixelPtr
+{
+public:
+    void    operator++()       { mpPixel += 3; }
+
+    PIXBYTE GetRed() const     { return mpPixel[0]; }
+    PIXBYTE GetGreen() const   { return mpPixel[1]; }
+    PIXBYTE GetBlue() const    { return mpPixel[2]; }
+    static PIXBYTE GetAlpha()  { return 255; }
+    static void SetAlpha( PIXBYTE ) {}
+
+    void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
+    {
+        mpPixel[0] = r;
+        mpPixel[1] = g;
+        mpPixel[2] = b;
+    }
+};
+
+template <>
+class TrueColorPixelPtr<ScanlineFormat::N24BitTcBgr> : public BasePixelPtr
+{
+public:
+    void    operator++()        { mpPixel += 3; }
+
+    PIXBYTE GetRed() const      { return mpPixel[2]; }
+    PIXBYTE GetGreen() const    { return mpPixel[1]; }
+    PIXBYTE GetBlue() const     { return mpPixel[0]; }
+    static PIXBYTE GetAlpha()   { return 255; }
+    static void SetAlpha( PIXBYTE ) {}
+
+    void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
+    {
+        mpPixel[0] = b;
+        mpPixel[1] = g;
+        mpPixel[2] = r;
+    }
+};
+
+template <>
+class TrueColorPixelPtr<ScanlineFormat::N32BitTcArgb> : public BasePixelPtr
+{
+public:
+    void    operator++()        { mpPixel += 4; }
+
+    PIXBYTE GetRed() const      { return mpPixel[1]; }
+    PIXBYTE GetGreen() const    { return mpPixel[2]; }
+    PIXBYTE GetBlue() const     { return mpPixel[3]; }
+    PIXBYTE GetAlpha() const    { return mpPixel[0]; }
+    void SetAlpha( PIXBYTE a ) const { mpPixel[0] = a; }
+
+    void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
+    {
+        mpPixel[1] = r;
+        mpPixel[2] = g;
+        mpPixel[3] = b;
+    }
+};
+
+template <>
+class TrueColorPixelPtr<ScanlineFormat::N32BitTcAbgr> : public BasePixelPtr
+{
+public:
+    void    operator++()        { mpPixel += 4; }
+
+    PIXBYTE GetRed() const      { return mpPixel[3]; }
+    PIXBYTE GetGreen() const    { return mpPixel[2]; }
+    PIXBYTE GetBlue() const     { return mpPixel[1]; }
+    PIXBYTE GetAlpha() const    { return mpPixel[0]; }
+    void SetAlpha( PIXBYTE a ) const { mpPixel[0] = a; }
+
+    void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
+    {
+        mpPixel[1] = b;
+        mpPixel[2] = g;
+        mpPixel[3] = r;
+    }
+};
+
+template <>
+class TrueColorPixelPtr<ScanlineFormat::N32BitTcRgba> : public BasePixelPtr
+{
+public:
+    void    operator++()            { mpPixel += 4; }
+
+    PIXBYTE GetRed() const          { return mpPixel[0]; }
+    PIXBYTE GetGreen() const        { return mpPixel[1]; }
+    PIXBYTE GetBlue() const         { return mpPixel[2]; }
+    PIXBYTE GetAlpha() const        { return mpPixel[3]; }
+    void SetAlpha( PIXBYTE a ) const{ mpPixel[3] = a; }
+
+    void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
+    {
+        mpPixel[0] = r;
+        mpPixel[1] = g;
+        mpPixel[2] = b;
+    }
+};
+
+template <>
+class TrueColorPixelPtr<ScanlineFormat::N32BitTcBgra> : public BasePixelPtr
+{
+public:
+    void    operator++()            { mpPixel += 4; }
+
+    PIXBYTE GetRed() const          { return mpPixel[2]; }
+    PIXBYTE GetGreen() const        { return mpPixel[1]; }
+    PIXBYTE GetBlue() const         { return mpPixel[0]; }
+    PIXBYTE GetAlpha() const        { return mpPixel[3]; }
+    void SetAlpha( PIXBYTE a ) const{ mpPixel[3] = a; }
+
+    void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
+    {
+        mpPixel[0] = b;
+        mpPixel[1] = g;
+        mpPixel[2] = r;
+    }
+};
+
+// This assumes the content uses the grayscale palette (needs to be checked
+// by code allowing the use of the format).
+// Only reading color is implemented, since e.g. 24bpp input couldn't be
+// easily guaranteed to be grayscale.
+template <>
+class TrueColorPixelPtr<ScanlineFormat::N8BitPal> : public BasePixelPtr
+{
+public:
+    void    operator++()                    { mpPixel += 1; }
+
+    PIXBYTE GetRed() const      { return mpPixel[0]; }
+    PIXBYTE GetGreen() const    { return mpPixel[0]; }
+    PIXBYTE GetBlue() const     { return mpPixel[0]; }
+    static PIXBYTE GetAlpha()   { return 255; }
+};
+
+}
+
+// converting truecolor formats
+template <ScanlineFormat SRCFMT, ScanlineFormat DSTFMT>
+static void ImplConvertPixel( const TrueColorPixelPtr<DSTFMT>& rDst,
+    const TrueColorPixelPtr<SRCFMT>& rSrc )
+{
+    rDst.SetColor( rSrc.GetRed(), rSrc.GetGreen(), rSrc.GetBlue() );
+    rDst.SetAlpha( rSrc.GetAlpha() );
+}
+
+template <ScanlineFormat SRCFMT, ScanlineFormat DSTFMT>
+static void ImplConvertLine( const TrueColorPixelPtr<DSTFMT>& rDst,
+    const TrueColorPixelPtr<SRCFMT>& rSrc, int nPixelCount )
+{
+    TrueColorPixelPtr<DSTFMT> aDst( rDst );
+    TrueColorPixelPtr<SRCFMT> aSrc( rSrc );
+    while( --nPixelCount >= 0 )
+    {
+        ImplConvertPixel( aDst, aSrc );
+        ++aSrc;
+        ++aDst;
+    }
+}
+
+// alpha blending truecolor pixels
+template <ScanlineFormat SRCFMT, ScanlineFormat DSTFMT>
+static void ImplBlendPixels( const TrueColorPixelPtr<DSTFMT>& rDst,
+    const TrueColorPixelPtr<SRCFMT>& rSrc, unsigned nAlphaVal )
+{
+    static const unsigned nAlphaShift = 8;
+    if( !nAlphaVal )
+        ImplConvertPixel( rDst, rSrc );
+    else if( nAlphaVal != ~(~0U << nAlphaShift) )
+    {
+        int nR = rDst.GetRed();
+        int nS = rSrc.GetRed();
+        nR = nS + (((nR - nS) * nAlphaVal) >> nAlphaShift);
+
+        int nG = rDst.GetGreen();
+        nS = rSrc.GetGreen();
+        nG = nS + (((nG - nS) * nAlphaVal) >> nAlphaShift);
+
+        int nB = rDst.GetBlue();
+        nS = rSrc.GetBlue();
+        nB = nS + (((nB - nS) * nAlphaVal) >> nAlphaShift);
+
+        rDst.SetColor( sal::static_int_cast<PIXBYTE>(nR),
+                       sal::static_int_cast<PIXBYTE>(nG),
+                       sal::static_int_cast<PIXBYTE>(nB) );
+    }
+}
+
+template <ScanlineFormat MASKFMT, ScanlineFormat SRCFMT, ScanlineFormat DSTFMT>
+static void ImplBlendLines( const TrueColorPixelPtr<DSTFMT>& rDst,
+    const TrueColorPixelPtr<SRCFMT>& rSrc, const TrueColorPixelPtr<MASKFMT>& rMsk,
+    int nPixelCount )
+{
+    TrueColorPixelPtr<MASKFMT> aMsk( rMsk );
+    TrueColorPixelPtr<DSTFMT> aDst( rDst );
+    TrueColorPixelPtr<SRCFMT> aSrc( rSrc );
+    while( --nPixelCount >= 0 )
+    {
+        // VCL masks store alpha as color, hence the GetRed() and not GetAlpha().
+        ImplBlendPixels(aDst, aSrc, aMsk.GetRed());
+        ++aDst;
+        ++aSrc;
+        ++aMsk;
+    }
+}
+
+static bool ImplCopyImage( BitmapBuffer& rDstBuffer, const BitmapBuffer& rSrcBuffer )
+{
+    const int nSrcLinestep = rSrcBuffer.mnScanlineSize;
+    int nDstLinestep = rDstBuffer.mnScanlineSize;
+
+    const PIXBYTE* pRawSrc = rSrcBuffer.mpBits;
+    PIXBYTE* pRawDst = rDstBuffer.mpBits;
+
+    // source and destination don't match upside down
+    if( ScanlineFormat::TopDown & (rSrcBuffer.mnFormat ^ rDstBuffer.mnFormat)  )
+    {
+        pRawDst += (rSrcBuffer.mnHeight - 1) * nDstLinestep;
+        nDstLinestep = -rDstBuffer.mnScanlineSize;
+    }
+    else if( nSrcLinestep == nDstLinestep )
+    {
+        memcpy( pRawDst, pRawSrc, rSrcBuffer.mnHeight * nDstLinestep );
+        return true;
+    }
+
+    int nByteWidth = nSrcLinestep;
+    if( nByteWidth > rDstBuffer.mnScanlineSize )
+        nByteWidth = rDstBuffer.mnScanlineSize;
+
+    for( int y = rSrcBuffer.mnHeight; --y >= 0; )
+    {
+        memcpy( pRawDst, pRawSrc, nByteWidth );
+        pRawSrc += nSrcLinestep;
+        pRawDst += nDstLinestep;
+    }
+
+    return true;
+}
+
+template <ScanlineFormat DSTFMT,ScanlineFormat SRCFMT>
+static bool ImplConvertToBitmap( TrueColorPixelPtr<SRCFMT>& rSrcLine,
+    BitmapBuffer& rDstBuffer, const BitmapBuffer& rSrcBuffer )
+{
+    // help the compiler to avoid instantiations of unneeded conversions
+    SAL_WARN_IF( SRCFMT == DSTFMT, "vcl.gdi", "ImplConvertToBitmap into same format");
+    if( SRCFMT == DSTFMT )
+        return false;
+
+    const int nSrcLinestep = rSrcBuffer.mnScanlineSize;
+    int nDstLinestep = rDstBuffer.mnScanlineSize;
+
+    TrueColorPixelPtr<DSTFMT> aDstLine; aDstLine.SetRawPtr( rDstBuffer.mpBits );
+
+    // source and destination don't match upside down
+    if( ScanlineFormat::TopDown & (rSrcBuffer.mnFormat ^ rDstBuffer.mnFormat) )
+    {
+        aDstLine.AddByteOffset( (rSrcBuffer.mnHeight - 1) * nDstLinestep );
+        nDstLinestep = -nDstLinestep;
+    }
+
+    for( int y = rSrcBuffer.mnHeight; --y >= 0; )
+    {
+        ImplConvertLine( aDstLine, rSrcLine, rSrcBuffer.mnWidth );
+        rSrcLine.AddByteOffset( nSrcLinestep );
+        aDstLine.AddByteOffset( nDstLinestep );
+    }
+
+    return true;
+}
+
+template <ScanlineFormat SRCFMT>
+static bool ImplConvertFromBitmap( BitmapBuffer& rDst, const BitmapBuffer& rSrc )
+{
+    TrueColorPixelPtr<SRCFMT> aSrcType; aSrcType.SetRawPtr( rSrc.mpBits );
+
+    // select the matching instantiation for the destination's bitmap format
+    switch (RemoveScanline(rDst.mnFormat))
+    {
+        case ScanlineFormat::N1BitMsbPal:
+        case ScanlineFormat::N8BitPal:
+            break;
+
+        case ScanlineFormat::N32BitTcMask:
+//            return ImplConvertToBitmap<ScanlineFormat::N32BitTcMask>( aSrcType, rDst, rSrc );
+            break;
+
+        case ScanlineFormat::N24BitTcBgr:
+            return ImplConvertToBitmap<ScanlineFormat::N24BitTcBgr>( aSrcType, rDst, rSrc );
+        case ScanlineFormat::N24BitTcRgb:
+            return ImplConvertToBitmap<ScanlineFormat::N24BitTcRgb>( aSrcType, rDst, rSrc );
+
+        case ScanlineFormat::N32BitTcAbgr:
+            return ImplConvertToBitmap<ScanlineFormat::N32BitTcAbgr>( aSrcType, rDst, rSrc );
+        case ScanlineFormat::N32BitTcArgb:
+            return ImplConvertToBitmap<ScanlineFormat::N32BitTcArgb>( aSrcType, rDst, rSrc );
+        case ScanlineFormat::N32BitTcBgra:
+            return ImplConvertToBitmap<ScanlineFormat::N32BitTcBgra>( aSrcType, rDst, rSrc );
+        case ScanlineFormat::N32BitTcRgba:
+            return ImplConvertToBitmap<ScanlineFormat::N32BitTcRgba>( aSrcType, rDst, rSrc );
+        default: break;
+    }
+
+    static int nNotAccelerated = 0;
+    SAL_WARN_IF( rSrc.mnWidth * rSrc.mnHeight >= 4000 && ++nNotAccelerated == 100,
+                 "vcl.gdi",
+                 "ImplConvertFromBitmap for not accelerated case (" << std::hex << static_cast<int>(rSrc.mnFormat) << "->" << static_cast<int>(rDst.mnFormat) << ")" );
+
+    return false;
+}
+
+// A universal stretching conversion is overkill in most common situations
+// => performance benefits for speeding up the non-stretching cases
+bool ImplFastBitmapConversion( BitmapBuffer& rDst, const BitmapBuffer& rSrc,
+    const SalTwoRect& rTR )
+{
+    // TODO:horizontal mirroring not implemented yet
+    if( rTR.mnDestWidth < 0 )
+        return false;
+    // vertical mirroring
+    if( rTR.mnDestHeight < 0 )
+        // TODO: rDst.mnFormat ^= ScanlineFormat::TopDown;
+        return false;
+
+    // offsetted conversion is not implemented yet
+    if( rTR.mnSrcX || rTR.mnSrcY )
+        return false;
+    if( rTR.mnDestX || rTR.mnDestY )
+        return false;
+
+    // stretched conversion is not implemented yet
+    if( rTR.mnDestWidth != rTR.mnSrcWidth )
+        return false;
+    if( rTR.mnDestHeight!= rTR.mnSrcHeight )
+        return false;
+
+    // check source image size
+    if( rSrc.mnWidth < rTR.mnSrcX + rTR.mnSrcWidth )
+        return false;
+    if( rSrc.mnHeight < rTR.mnSrcY + rTR.mnSrcHeight )
+        return false;
+
+    // check dest image size
+    if( rDst.mnWidth < rTR.mnDestX + rTR.mnDestWidth )
+        return false;
+    if( rDst.mnHeight < rTR.mnDestY + rTR.mnDestHeight )
+        return false;
+
+    const ScanlineFormat nSrcFormat = RemoveScanline(rSrc.mnFormat);
+    const ScanlineFormat nDstFormat = RemoveScanline(rDst.mnFormat);
+
+    // special handling of trivial cases
+    if( nSrcFormat == nDstFormat )
+    {
+        // accelerated palette conversions not yet implemented
+        if( rSrc.maPalette != rDst.maPalette )
+            return false;
+        return ImplCopyImage( rDst, rSrc );
+    }
+
+    // select the matching instantiation for the source's bitmap format
+    switch( nSrcFormat )
+    {
+        case ScanlineFormat::N1BitMsbPal:
+            break;
+
+        case ScanlineFormat::N32BitTcMask:
+//            return ImplConvertFromBitmap<ScanlineFormat::N32BitTcMask>( rDst, rSrc );
+            break;
+
+        case ScanlineFormat::N8BitPal:
+            if(rSrc.maPalette.IsGreyPalette8Bit())
+                return ImplConvertFromBitmap<ScanlineFormat::N8BitPal>( rDst, rSrc );
+            break;
+
+        case ScanlineFormat::N24BitTcBgr:
+            return ImplConvertFromBitmap<ScanlineFormat::N24BitTcBgr>( rDst, rSrc );
+        case ScanlineFormat::N24BitTcRgb:
+            return ImplConvertFromBitmap<ScanlineFormat::N24BitTcRgb>( rDst, rSrc );
+
+        case ScanlineFormat::N32BitTcAbgr:
+            return ImplConvertFromBitmap<ScanlineFormat::N32BitTcAbgr>( rDst, rSrc );
+        case ScanlineFormat::N32BitTcArgb:
+            return ImplConvertFromBitmap<ScanlineFormat::N32BitTcArgb>( rDst, rSrc );
+        case ScanlineFormat::N32BitTcBgra:
+            return ImplConvertFromBitmap<ScanlineFormat::N32BitTcBgra>( rDst, rSrc );
+        case ScanlineFormat::N32BitTcRgba:
+            return ImplConvertFromBitmap<ScanlineFormat::N32BitTcRgba>( rDst, rSrc );
+        default: break;
+    }
+
+    static int nNotAccelerated = 0;
+    SAL_WARN_IF( rSrc.mnWidth * rSrc.mnHeight >= 4000 && ++nNotAccelerated == 100,
+                 "vcl.gdi",
+                 "ImplFastBitmapConversion for not accelerated case (" << std::hex << static_cast<int>(rSrc.mnFormat) << "->" << static_cast<int>(rDst.mnFormat) << ")" );
+
+    return false;
+}
+
+static inline ConstScanline ImplGetScanline( const BitmapBuffer& rBuf, tools::Long nY )
+{
+    if( rBuf.mnFormat & ScanlineFormat::TopDown )
+        return rBuf.mpBits + nY * rBuf.mnScanlineSize;
+    else
+        return rBuf.mpBits + (rBuf.mnHeight - 1 - nY) * rBuf.mnScanlineSize;
+}
+
+static inline Scanline ImplGetScanline( BitmapBuffer& rBuf, tools::Long nY )
+{
+    return const_cast<Scanline>(ImplGetScanline( const_cast<const BitmapBuffer&>(rBuf), nY ));
+}
+
+template <ScanlineFormat DSTFMT, ScanlineFormat SRCFMT>
+static bool ImplCopyToScanline( tools::Long nY, BitmapBuffer& rDst, TrueColorPixelPtr<SRCFMT>& rSrcLine, tools::Long nSrcWidth )
+{
+    TrueColorPixelPtr<DSTFMT> aDstType;
+    aDstType.SetRawPtr( ImplGetScanline( rDst, nY ));
+    ImplConvertLine( aDstType, rSrcLine, std::min( nSrcWidth, rDst.mnWidth ));
+    return true;
+}
+
+template <ScanlineFormat SRCFMT>
+static bool ImplCopyFromScanline( tools::Long nY, BitmapBuffer& rDst, ConstScanline aSrcScanline, tools::Long nSrcWidth )
+{
+    TrueColorPixelPtr<SRCFMT> aSrcType;
+    aSrcType.SetRawPtr( const_cast<Scanline>( aSrcScanline ));
+    // select the matching instantiation for the destination's bitmap format
+    switch( RemoveScanline( rDst.mnFormat ))
+    {
+        case ScanlineFormat::N24BitTcBgr:
+            return ImplCopyToScanline<ScanlineFormat::N24BitTcBgr>( nY, rDst, aSrcType, nSrcWidth );
+        case ScanlineFormat::N24BitTcRgb:
+            return ImplCopyToScanline<ScanlineFormat::N24BitTcRgb>( nY, rDst, aSrcType, nSrcWidth );
+
+        case ScanlineFormat::N32BitTcAbgr:
+            return ImplCopyToScanline<ScanlineFormat::N32BitTcAbgr>( nY, rDst, aSrcType, nSrcWidth );
+        case ScanlineFormat::N32BitTcArgb:
+            return ImplCopyToScanline<ScanlineFormat::N32BitTcArgb>( nY, rDst, aSrcType, nSrcWidth );
+        case ScanlineFormat::N32BitTcBgra:
+            return ImplCopyToScanline<ScanlineFormat::N32BitTcBgra>( nY, rDst, aSrcType, nSrcWidth );
+        case ScanlineFormat::N32BitTcRgba:
+            return ImplCopyToScanline<ScanlineFormat::N32BitTcRgba>( nY, rDst, aSrcType, nSrcWidth );
+        default:
+            break;
+    }
+    return false;
+
+}
+
+bool ImplFastCopyScanline( tools::Long nY, BitmapBuffer& rDst, ConstScanline aSrcScanline,
+    ScanlineFormat nSrcScanlineFormat, sal_uInt32 nSrcScanlineSize)
+{
+    if( rDst.mnHeight <= nY )
+        return false;
+
+    const ScanlineFormat nSrcFormat = RemoveScanline(nSrcScanlineFormat);
+    const ScanlineFormat nDstFormat = RemoveScanline(rDst.mnFormat);
+
+    // special handling of trivial cases
+    if( nSrcFormat == nDstFormat )
+    {
+        memcpy( ImplGetScanline( rDst, nY ), aSrcScanline, std::min<tools::Long>(nSrcScanlineSize, rDst.mnScanlineSize));
+        return true;
+    }
+
+    // select the matching instantiation for the source's bitmap format
+    switch( nSrcFormat )
+    {
+        case ScanlineFormat::N24BitTcBgr:
+            return ImplCopyFromScanline<ScanlineFormat::N24BitTcBgr>( nY, rDst, aSrcScanline, nSrcScanlineSize / 3 );
+        case ScanlineFormat::N24BitTcRgb:
+            return ImplCopyFromScanline<ScanlineFormat::N24BitTcRgb>( nY, rDst, aSrcScanline, nSrcScanlineSize / 3 );
+
+        case ScanlineFormat::N32BitTcAbgr:
+            return ImplCopyFromScanline<ScanlineFormat::N32BitTcAbgr>( nY, rDst, aSrcScanline, nSrcScanlineSize / 4 );
+        case ScanlineFormat::N32BitTcArgb:
+            return ImplCopyFromScanline<ScanlineFormat::N32BitTcArgb>( nY, rDst, aSrcScanline, nSrcScanlineSize / 4 );
+        case ScanlineFormat::N32BitTcBgra:
+            return ImplCopyFromScanline<ScanlineFormat::N32BitTcBgra>( nY, rDst, aSrcScanline, nSrcScanlineSize / 4 );
+        case ScanlineFormat::N32BitTcRgba:
+            return ImplCopyFromScanline<ScanlineFormat::N32BitTcRgba>( nY, rDst, aSrcScanline, nSrcScanlineSize / 4 );
+        default:
+            break;
+    }
+    return false;
+}
+
+bool ImplFastCopyScanline( tools::Long nY, BitmapBuffer& rDst, const BitmapBuffer& rSrc)
+{
+    if( nY >= rDst.mnHeight )
+        return false;
+    if( rSrc.maPalette != rDst.maPalette )
+        return false;
+    return ImplFastCopyScanline( nY, rDst, ImplGetScanline( rSrc, nY ), rSrc.mnFormat, rSrc.mnScanlineSize);
+}
+
+template <ScanlineFormat DSTFMT, ScanlineFormat SRCFMT> //,sal_uLong MSKFMT>
+static bool ImplBlendToBitmap( TrueColorPixelPtr<SRCFMT>& rSrcLine,
+    BitmapBuffer& rDstBuffer, const BitmapBuffer& rSrcBuffer,
+    const BitmapBuffer& rMskBuffer )
+{
+    SAL_WARN_IF(( rMskBuffer.mnFormat & ~ScanlineFormat::TopDown ) != ScanlineFormat::N8BitPal,
+        "vcl.gdi", "FastBmp BlendImage: unusual MSKFMT" );
+
+    const int nSrcLinestep = rSrcBuffer.mnScanlineSize;
+    int nMskLinestep = rMskBuffer.mnScanlineSize;
+    int nDstLinestep = rDstBuffer.mnScanlineSize;
+
+    TrueColorPixelPtr<ScanlineFormat::N8BitPal> aMskLine; aMskLine.SetRawPtr( rMskBuffer.mpBits );
+    TrueColorPixelPtr<DSTFMT> aDstLine; aDstLine.SetRawPtr( rDstBuffer.mpBits );
+
+    // special case for single line masks
+    if( rMskBuffer.mnHeight == 1 )
+        nMskLinestep = 0;
+
+    // source and mask don't match: upside down
+    if( (rSrcBuffer.mnFormat ^ rMskBuffer.mnFormat) & ScanlineFormat::TopDown )
+    {
+        aMskLine.AddByteOffset( (rSrcBuffer.mnHeight - 1) * nMskLinestep );
+        nMskLinestep = -nMskLinestep;
+    }
+
+    // source and destination don't match: upside down
+    if( (rSrcBuffer.mnFormat ^ rDstBuffer.mnFormat) & ScanlineFormat::TopDown )
+    {
+        aDstLine.AddByteOffset( (rDstBuffer.mnHeight - 1) * nDstLinestep );
+        nDstLinestep = -nDstLinestep;
+    }
+
+    assert(rDstBuffer.mnHeight <= rSrcBuffer.mnHeight && "not sure about that?");
+    for (int y = rDstBuffer.mnHeight; --y >= 0;)
+    {
+        ImplBlendLines(aDstLine, rSrcLine, aMskLine, rDstBuffer.mnWidth);
+        aDstLine.AddByteOffset( nDstLinestep );
+        rSrcLine.AddByteOffset( nSrcLinestep );
+        aMskLine.AddByteOffset( nMskLinestep );
+    }
+
+    return true;
+}
+
+// some specializations to reduce the code size
+template <>
+bool ImplBlendToBitmap<ScanlineFormat::N24BitTcBgr,ScanlineFormat::N24BitTcBgr>(
+    TrueColorPixelPtr<ScanlineFormat::N24BitTcBgr>&,
+    BitmapBuffer& rDstBuffer, const BitmapBuffer& rSrcBuffer,
+    const BitmapBuffer& rMskBuffer )
+ {
+    TrueColorPixelPtr<ScanlineFormat::N24BitTcRgb> aSrcType; aSrcType.SetRawPtr( rSrcBuffer.mpBits );
+    return ImplBlendToBitmap<ScanlineFormat::N24BitTcRgb>( aSrcType, rDstBuffer, rSrcBuffer, rMskBuffer );
+ }
+
+template <>
+bool ImplBlendToBitmap<ScanlineFormat::N32BitTcAbgr,ScanlineFormat::N32BitTcAbgr>(
+    TrueColorPixelPtr<ScanlineFormat::N32BitTcAbgr>&,
+    BitmapBuffer& rDstBuffer, const BitmapBuffer& rSrcBuffer,
+    const BitmapBuffer& rMskBuffer )
+ {
+    TrueColorPixelPtr<ScanlineFormat::N32BitTcArgb> aSrcType; aSrcType.SetRawPtr( rSrcBuffer.mpBits );
+    return ImplBlendToBitmap<ScanlineFormat::N32BitTcArgb>( aSrcType, rDstBuffer, rSrcBuffer, rMskBuffer );
+ }
+
+template <>
+bool ImplBlendToBitmap<ScanlineFormat::N32BitTcBgra,ScanlineFormat::N32BitTcBgra>(
+    TrueColorPixelPtr<ScanlineFormat::N32BitTcBgra>&,
+    BitmapBuffer& rDstBuffer, const BitmapBuffer& rSrcBuffer,
+    const BitmapBuffer& rMskBuffer )
+ {
+    TrueColorPixelPtr<ScanlineFormat::N32BitTcRgba> aSrcType; aSrcType.SetRawPtr( rSrcBuffer.mpBits );
+    return ImplBlendToBitmap<ScanlineFormat::N32BitTcRgba>( aSrcType, rDstBuffer, rSrcBuffer, rMskBuffer );
+ }
+
+template <ScanlineFormat SRCFMT>
+static bool ImplBlendFromBitmap( BitmapBuffer& rDst, const BitmapBuffer& rSrc, const BitmapBuffer& rMsk )
+{
+    TrueColorPixelPtr<SRCFMT> aSrcType; aSrcType.SetRawPtr( rSrc.mpBits );
+
+    // select the matching instantiation for the destination's bitmap format
+    switch (RemoveScanline(rDst.mnFormat))
+    {
+        case ScanlineFormat::N1BitMsbPal:
+        case ScanlineFormat::N8BitPal:
+            break;
+
+        case ScanlineFormat::N32BitTcMask:
+//            return ImplBlendToBitmap<ScanlineFormat::N32BitTcMask>( aSrcType, rDst, rSrc, rMsk );
+            break;
+
+        case ScanlineFormat::N24BitTcBgr:
+            return ImplBlendToBitmap<ScanlineFormat::N24BitTcBgr>( aSrcType, rDst, rSrc, rMsk );
+        case ScanlineFormat::N24BitTcRgb:
+            return ImplBlendToBitmap<ScanlineFormat::N24BitTcRgb>( aSrcType, rDst, rSrc, rMsk );
+
+        case ScanlineFormat::N32BitTcAbgr:
+            return ImplBlendToBitmap<ScanlineFormat::N32BitTcAbgr>( aSrcType, rDst, rSrc, rMsk );
+        case ScanlineFormat::N32BitTcArgb:
+            return ImplBlendToBitmap<ScanlineFormat::N32BitTcArgb>( aSrcType, rDst, rSrc, rMsk );
+        case ScanlineFormat::N32BitTcBgra:
+            return ImplBlendToBitmap<ScanlineFormat::N32BitTcBgra>( aSrcType, rDst, rSrc, rMsk );
+        case ScanlineFormat::N32BitTcRgba:
+            return ImplBlendToBitmap<ScanlineFormat::N32BitTcRgba>( aSrcType, rDst, rSrc, rMsk );
+        default: break;
+    }
+
+    static int nNotAccelerated = 0;
+    SAL_WARN_IF( rSrc.mnWidth * rSrc.mnHeight >= 4000 && ++nNotAccelerated == 100,
+                 "vcl.gdi",
+                 "ImplBlendFromBitmap for not accelerated case (" << std::hex << static_cast<int>(rSrc.mnFormat) << "*" << static_cast<int>(rMsk.mnFormat) << "->" << static_cast<int>(rDst.mnFormat) );
+    return false;
+}
+
+bool ImplFastBitmapBlending( BitmapWriteAccess const & rDstWA,
+    const BitmapReadAccess& rSrcRA, const BitmapReadAccess& rMskRA,
+    const SalTwoRect& rTR )
+{
+    // accelerated blending of paletted bitmaps not implemented yet
+    if( rSrcRA.HasPalette() )
+        return false;
+    if( rDstWA.HasPalette() )
+        return false;
+    // TODO: either get rid of mask's use of 8BIT_PAL or check the palette
+
+    // horizontal mirroring not implemented yet
+    if( rTR.mnDestWidth < 0 )
+        return false;
+    // vertical mirroring
+    if( rTR.mnDestHeight < 0 )
+        // TODO: rDst.mnFormat ^= ScanlineFormat::TopDown;
+        return false;
+
+    // offsetted blending is not implemented yet
+    if( rTR.mnSrcX || rTR.mnSrcY )
+        return false;
+    if( rTR.mnDestX || rTR.mnDestY )
+        return false;
+
+    // stretched blending is not implemented yet
+    if( rTR.mnDestWidth != rTR.mnSrcWidth )
+        return false;
+    if( rTR.mnDestHeight!= rTR.mnSrcHeight )
+        return false;
+
+    // check source image size
+    if( rSrcRA.Width() < rTR.mnSrcX + rTR.mnSrcWidth )
+        return false;
+    if( rSrcRA.Height() < rTR.mnSrcY + rTR.mnSrcHeight )
+        return false;
+
+    // check mask image size
+    if( rMskRA.Width() < rTR.mnSrcX + rTR.mnSrcWidth )
+        return false;
+    if( rMskRA.Height() < rTR.mnSrcY + rTR.mnSrcHeight )
+        if( rMskRA.Height() != 1 )
+            return false;
+
+    // check dest image size
+    if( rDstWA.Width() < rTR.mnDestX + rTR.mnDestWidth )
+        return false;
+    if( rDstWA.Height() < rTR.mnDestY + rTR.mnDestHeight )
+        return false;
+
+    BitmapBuffer& rDst = *rDstWA.ImplGetBitmapBuffer();
+    const BitmapBuffer& rSrc = *rSrcRA.ImplGetBitmapBuffer();
+    const BitmapBuffer& rMsk = *rMskRA.ImplGetBitmapBuffer();
+
+    const ScanlineFormat nSrcFormat = RemoveScanline(rSrc.mnFormat);
+
+    // select the matching instantiation for the source's bitmap format
+    switch( nSrcFormat )
+    {
+        case ScanlineFormat::N1BitMsbPal:
+            break;
+
+        case ScanlineFormat::N32BitTcMask:
+//            return ImplBlendFromBitmap<ScanlineFormat::N32BitTcMask>( rDst, rSrc );
+            break;
+
+        case ScanlineFormat::N8BitPal:
+            if(rSrc.maPalette.IsGreyPalette8Bit())
+                return ImplBlendFromBitmap<ScanlineFormat::N8BitPal>( rDst, rSrc, rMsk );
+            break;
+
+        case ScanlineFormat::N24BitTcBgr:
+            return ImplBlendFromBitmap<ScanlineFormat::N24BitTcBgr>( rDst, rSrc, rMsk );
+        case ScanlineFormat::N24BitTcRgb:
+            return ImplBlendFromBitmap<ScanlineFormat::N24BitTcRgb>( rDst, rSrc, rMsk );
+
+        case ScanlineFormat::N32BitTcAbgr:
+            return ImplBlendFromBitmap<ScanlineFormat::N32BitTcAbgr>( rDst, rSrc, rMsk );
+        case ScanlineFormat::N32BitTcArgb:
+            return ImplBlendFromBitmap<ScanlineFormat::N32BitTcArgb>( rDst, rSrc, rMsk );
+        case ScanlineFormat::N32BitTcBgra:
+            return ImplBlendFromBitmap<ScanlineFormat::N32BitTcBgra>( rDst, rSrc, rMsk );
+        case ScanlineFormat::N32BitTcRgba:
+            return ImplBlendFromBitmap<ScanlineFormat::N32BitTcRgba>( rDst, rSrc, rMsk );
+        default: break;
+    }
+
+    static int nNotAccelerated = 0;
+    SAL_WARN_IF( rSrc.mnWidth * rSrc.mnHeight >= 4000 && ++nNotAccelerated == 100,
+                 "vcl.gdi",
+                 "ImplFastBlend for not accelerated case (" << std::hex << static_cast<int>(rSrc.mnFormat) << "*" << static_cast<int>(rMsk.mnFormat) << "->" << static_cast<int>(rDst.mnFormat) << ")" );
+
+    return false;
+}
+
+bool ImplFastEraseBitmap( BitmapBuffer& rDst, const BitmapColor& rColor )
+{
+    const ScanlineFormat nDstFormat = RemoveScanline(rDst.mnFormat);
+
+    // erasing a bitmap is often just a byte-wise memory fill
+    bool bByteFill = true;
+    sal_uInt8 nFillByte;
+
+    switch( nDstFormat )
+    {
+        case ScanlineFormat::N1BitMsbPal:
+            nFillByte = rColor.GetIndex();
+            nFillByte = static_cast<sal_uInt8>( -(nFillByte & 1) ); // 0x00 or 0xFF
+            break;
+        case ScanlineFormat::N8BitPal:
+            nFillByte = rColor.GetIndex();
+            break;
+
+        case ScanlineFormat::N24BitTcBgr:
+        case ScanlineFormat::N24BitTcRgb:
+            nFillByte = rColor.GetRed();
+            if( (nFillByte != rColor.GetGreen())
+            ||  (nFillByte != rColor.GetBlue()) )
+                bByteFill = false;
+            break;
+
+        default:
+            bByteFill = false;
+            nFillByte = 0x00;
+            break;
+    }
+
+    if( bByteFill )
+    {
+        tools::Long nByteCount = rDst.mnHeight * rDst.mnScanlineSize;
+        memset( rDst.mpBits, nFillByte, nByteCount );
+        return true;
+    }
+
+    // TODO: handle other bitmap formats
+    switch( nDstFormat )
+    {
+        case ScanlineFormat::N32BitTcMask:
+
+        case ScanlineFormat::N24BitTcBgr:
+        case ScanlineFormat::N24BitTcRgb:
+
+        case ScanlineFormat::N32BitTcAbgr:
+        case ScanlineFormat::N32BitTcArgb:
+        case ScanlineFormat::N32BitTcBgra:
+        case ScanlineFormat::N32BitTcRgba:
+            break;
+
+        default:
+            break;
+    }
+
+    return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/dibtools.cxx b/vcl/source/bitmap/dibtools.cxx
new file mode 100644
index 0000000000..4eb15ac284
--- /dev/null
+++ b/vcl/source/bitmap/dibtools.cxx
@@ -0,0 +1,1769 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+#include <sal/log.hxx>
+
+#include <cassert>
+
+#include <o3tl/safeint.hxx>
+#include <vcl/dibtools.hxx>
+#include <comphelper/fileformat.h>
+#include <tools/zcodec.hxx>
+#include <tools/stream.hxx>
+#include <tools/fract.hxx>
+#include <tools/helpers.hxx>
+#include <tools/GenericTypeSerializer.hxx>
+#include <unotools/configmgr.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/BitmapWriteAccess.hxx>
+#include <memory>
+
+#define DIBCOREHEADERSIZE       ( 12UL )
+#define DIBINFOHEADERSIZE       ( sizeof(DIBInfoHeader) )
+#define DIBV5HEADERSIZE         ( sizeof(DIBV5Header) )
+
+// - DIBInfoHeader and DIBV5Header
+
+typedef sal_Int32 FXPT2DOT30;
+
+namespace
+{
+
+struct CIEXYZ
+{
+    FXPT2DOT30      aXyzX;
+    FXPT2DOT30      aXyzY;
+    FXPT2DOT30      aXyzZ;
+
+    CIEXYZ()
+    :   aXyzX(0),
+        aXyzY(0),
+        aXyzZ(0)
+    {}
+};
+
+struct CIEXYZTriple
+{
+    CIEXYZ          aXyzRed;
+    CIEXYZ          aXyzGreen;
+    CIEXYZ          aXyzBlue;
+
+    CIEXYZTriple()
+    {}
+};
+
+struct DIBInfoHeader
+{
+    sal_uInt32      nSize;
+    sal_Int32       nWidth;
+    sal_Int32       nHeight;
+    sal_uInt16      nPlanes;
+    sal_uInt16      nBitCount;
+    sal_uInt32      nCompression;
+    sal_uInt32      nSizeImage;
+    sal_Int32       nXPelsPerMeter;
+    sal_Int32       nYPelsPerMeter;
+    sal_uInt32      nColsUsed;
+    sal_uInt32      nColsImportant;
+
+    DIBInfoHeader()
+    :   nSize(0),
+        nWidth(0),
+        nHeight(0),
+        nPlanes(0),
+        nBitCount(0),
+        nCompression(0),
+        nSizeImage(0),
+        nXPelsPerMeter(0),
+        nYPelsPerMeter(0),
+        nColsUsed(0),
+        nColsImportant(0)
+    {}
+};
+
+struct DIBV5Header : public DIBInfoHeader
+{
+    sal_uInt32      nV5RedMask;
+    sal_uInt32      nV5GreenMask;
+    sal_uInt32      nV5BlueMask;
+    sal_uInt32      nV5AlphaMask;
+    sal_uInt32      nV5CSType;
+    CIEXYZTriple    aV5Endpoints;
+    sal_uInt32      nV5GammaRed;
+    sal_uInt32      nV5GammaGreen;
+    sal_uInt32      nV5GammaBlue;
+    sal_uInt32      nV5Intent;
+    sal_uInt32      nV5ProfileData;
+    sal_uInt32      nV5ProfileSize;
+    sal_uInt32      nV5Reserved;
+
+    DIBV5Header()
+    :   nV5RedMask(0),
+        nV5GreenMask(0),
+        nV5BlueMask(0),
+        nV5AlphaMask(0),
+        nV5CSType(0),
+        nV5GammaRed(0),
+        nV5GammaGreen(0),
+        nV5GammaBlue(0),
+        nV5Intent(0),
+        nV5ProfileData(0),
+        nV5ProfileSize(0),
+        nV5Reserved(0)
+    {}
+};
+
+vcl::PixelFormat convertToBPP(sal_uInt16 nCount)
+{
+    return (nCount <= 8) ? vcl::PixelFormat::N8_BPP :
+                           vcl::PixelFormat::N24_BPP;
+}
+
+bool isBitfieldCompression( ScanlineFormat nScanlineFormat )
+{
+    return ScanlineFormat::N32BitTcMask == nScanlineFormat;
+}
+
+bool ImplReadDIBInfoHeader(SvStream& rIStm, DIBV5Header& rHeader, bool& bTopDown, bool bMSOFormat)
+{
+    if (rIStm.remainingSize() <= 4)
+        return false;
+    // BITMAPINFOHEADER or BITMAPCOREHEADER or BITMAPV5HEADER
+    sal_uInt64 const aStartPos(rIStm.Tell());
+    rIStm.ReadUInt32( rHeader.nSize );
+
+    // BITMAPCOREHEADER
+    if ( rHeader.nSize == DIBCOREHEADERSIZE )
+    {
+        sal_Int16 nTmp16;
+
+        rIStm.ReadInt16( nTmp16 ); rHeader.nWidth = nTmp16;
+        rIStm.ReadInt16( nTmp16 ); rHeader.nHeight = nTmp16;
+        rIStm.ReadUInt16( rHeader.nPlanes );
+        rIStm.ReadUInt16( rHeader.nBitCount );
+    }
+    else if ( bMSOFormat && rHeader.nSize == DIBINFOHEADERSIZE )
+    {
+        sal_Int16 nTmp16(0);
+        rIStm.ReadInt16(nTmp16);
+        rHeader.nWidth = nTmp16;
+        rIStm.ReadInt16(nTmp16);
+        rHeader.nHeight = nTmp16;
+        sal_uInt8 nTmp8(0);
+        rIStm.ReadUChar(nTmp8);
+        rHeader.nPlanes = nTmp8;
+        rIStm.ReadUChar(nTmp8);
+        rHeader.nBitCount = nTmp8;
+        rIStm.ReadInt16(nTmp16);
+        rHeader.nSizeImage = nTmp16;
+        rIStm.ReadInt16(nTmp16);
+        rHeader.nCompression = nTmp16;
+        if ( !rHeader.nSizeImage ) // uncompressed?
+            rHeader.nSizeImage = ((rHeader.nWidth * rHeader.nBitCount + 31) & ~31) / 8 * rHeader.nHeight;
+        rIStm.ReadInt32( rHeader.nXPelsPerMeter );
+        rIStm.ReadInt32( rHeader.nYPelsPerMeter );
+        rIStm.ReadUInt32( rHeader.nColsUsed );
+        rIStm.ReadUInt32( rHeader.nColsImportant );
+    }
+    else
+    {
+        // BITMAPCOREHEADER, BITMAPV5HEADER or unknown. Read as far as possible
+        std::size_t nUsed(sizeof(rHeader.nSize));
+
+        auto readUInt16 = [&nUsed, &rHeader, &rIStm](sal_uInt16 & v) {
+            if (nUsed < rHeader.nSize) {
+                rIStm.ReadUInt16(v);
+                nUsed += sizeof(v);
+            }
+        };
+        auto readInt32 = [&nUsed, &rHeader, &rIStm](sal_Int32 & v) {
+            if (nUsed < rHeader.nSize) {
+                rIStm.ReadInt32(v);
+                nUsed += sizeof(v);
+            }
+        };
+        auto readUInt32 = [&nUsed, &rHeader, &rIStm](sal_uInt32 & v) {
+            if (nUsed < rHeader.nSize) {
+                rIStm.ReadUInt32(v);
+                nUsed += sizeof(v);
+            }
+        };
+
+        // read DIBInfoHeader entries
+        readInt32( rHeader.nWidth );
+        readInt32( rHeader.nHeight );
+        readUInt16( rHeader.nPlanes );
+        readUInt16( rHeader.nBitCount );
+        readUInt32( rHeader.nCompression );
+        readUInt32( rHeader.nSizeImage );
+        readInt32( rHeader.nXPelsPerMeter );
+        readInt32( rHeader.nYPelsPerMeter );
+        readUInt32( rHeader.nColsUsed );
+        readUInt32( rHeader.nColsImportant );
+
+        // read DIBV5HEADER members
+        readUInt32( rHeader.nV5RedMask );
+        readUInt32( rHeader.nV5GreenMask );
+        readUInt32( rHeader.nV5BlueMask );
+        readUInt32( rHeader.nV5AlphaMask );
+        readUInt32( rHeader.nV5CSType );
+
+        // read contained CIEXYZTriple's
+        readInt32( rHeader.aV5Endpoints.aXyzRed.aXyzX );
+        readInt32( rHeader.aV5Endpoints.aXyzRed.aXyzY );
+        readInt32( rHeader.aV5Endpoints.aXyzRed.aXyzZ );
+        readInt32( rHeader.aV5Endpoints.aXyzGreen.aXyzX );
+        readInt32( rHeader.aV5Endpoints.aXyzGreen.aXyzY );
+        readInt32( rHeader.aV5Endpoints.aXyzGreen.aXyzZ );
+        readInt32( rHeader.aV5Endpoints.aXyzBlue.aXyzX );
+        readInt32( rHeader.aV5Endpoints.aXyzBlue.aXyzY );
+        readInt32( rHeader.aV5Endpoints.aXyzBlue.aXyzZ );
+
+        readUInt32( rHeader.nV5GammaRed );
+        readUInt32( rHeader.nV5GammaGreen );
+        readUInt32( rHeader.nV5GammaBlue );
+        readUInt32( rHeader.nV5Intent );
+        readUInt32( rHeader.nV5ProfileData );
+        readUInt32( rHeader.nV5ProfileSize );
+        readUInt32( rHeader.nV5Reserved );
+
+        // Read color mask. An additional 12 bytes of color bitfields follow the info header (WinBMPv3-NT)
+        sal_uInt32 nColorMask = 0;
+        if (BITFIELDS == rHeader.nCompression && DIBINFOHEADERSIZE == rHeader.nSize)
+        {
+            rIStm.ReadUInt32( rHeader.nV5RedMask );
+            rIStm.ReadUInt32( rHeader.nV5GreenMask );
+            rIStm.ReadUInt32( rHeader.nV5BlueMask );
+            nColorMask = 12;
+        }
+
+        // seek to EndPos
+        if (!checkSeek(rIStm, aStartPos + rHeader.nSize + nColorMask))
+            return false;
+    }
+
+    if (!rIStm.good() || rHeader.nHeight == SAL_MIN_INT32)
+        return false;
+
+    if ( rHeader.nHeight < 0 )
+    {
+        bTopDown = true;
+        rHeader.nHeight *= -1;
+    }
+    else
+    {
+        bTopDown = false;
+    }
+
+    if ( rHeader.nWidth < 0 || rHeader.nXPelsPerMeter < 0 || rHeader.nYPelsPerMeter < 0 )
+    {
+        rIStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
+    }
+
+    // #144105# protect a little against damaged files
+    assert(rHeader.nHeight >= 0);
+    if (rHeader.nHeight != 0 && rHeader.nWidth >= 0
+        && (rHeader.nSizeImage / 16 / static_cast<sal_uInt32>(rHeader.nHeight)
+            > o3tl::make_unsigned(rHeader.nWidth)))
+    {
+        rHeader.nSizeImage = 0;
+    }
+
+
+    if (rHeader.nPlanes != 1)
+        return false;
+
+    if (rHeader.nBitCount != 0 && rHeader.nBitCount != 1 &&
+        rHeader.nBitCount != 4 && rHeader.nBitCount != 8 &&
+        rHeader.nBitCount != 16 && rHeader.nBitCount != 24 &&
+        rHeader.nBitCount != 32)
+    {
+        return false;
+    }
+
+    return rIStm.good();
+}
+
+bool ImplReadDIBPalette(SvStream& rIStm, BitmapPalette& rPal, bool bQuad)
+{
+    const sal_uInt16    nColors = rPal.GetEntryCount();
+    const sal_uLong     nPalSize = nColors * ( bQuad ? 4UL : 3UL );
+    BitmapColor     aPalColor;
+
+    std::unique_ptr<sal_uInt8[]> pEntries(new sal_uInt8[ nPalSize ]);
+    if (rIStm.ReadBytes(pEntries.get(), nPalSize) != nPalSize)
+    {
+        return false;
+    }
+
+    sal_uInt8* pTmpEntry = pEntries.get();
+    for( sal_uInt16 i = 0; i < nColors; i++ )
+    {
+        aPalColor.SetBlue( *pTmpEntry++ );
+        aPalColor.SetGreen( *pTmpEntry++ );
+        aPalColor.SetRed( *pTmpEntry++ );
+
+        if( bQuad )
+            pTmpEntry++;
+
+        rPal[i] = aPalColor;
+    }
+
+    return rIStm.GetError() == ERRCODE_NONE;
+}
+
+BitmapColor SanitizePaletteIndex(sal_uInt8 nIndex, BitmapPalette& rPalette)
+{
+    const sal_uInt16 nPaletteEntryCount = rPalette.GetEntryCount();
+    if (nPaletteEntryCount && nIndex >= nPaletteEntryCount)
+    {
+        auto nSanitizedIndex = nIndex % nPaletteEntryCount;
+        SAL_WARN_IF(nIndex != nSanitizedIndex, "vcl", "invalid colormap index: "
+                    << static_cast<unsigned int>(nIndex) << ", colormap len is: "
+                    << nPaletteEntryCount);
+        nIndex = nSanitizedIndex;
+    }
+    return BitmapColor(nIndex);
+}
+
+bool ImplDecodeRLE(sal_uInt8* pBuffer, DIBV5Header const & rHeader, BitmapWriteAccess& rAcc, BitmapPalette& rPalette, bool bRLE4)
+{
+    Scanline pRLE = pBuffer;
+    Scanline pEndRLE = pBuffer + rHeader.nSizeImage;
+    tools::Long        nY = rHeader.nHeight - 1;
+    const sal_uLong nWidth = rAcc.Width();
+    sal_uLong       nCountByte;
+    sal_uLong       nRunByte;
+    sal_uLong       nX = 0;
+    sal_uInt8       cTmp;
+    bool        bEndDecoding = false;
+
+    do
+    {
+        if (pRLE == pEndRLE)
+            return false;
+        if( ( nCountByte = *pRLE++ ) == 0 )
+        {
+            if (pRLE == pEndRLE)
+                return false;
+            nRunByte = *pRLE++;
+
+            if( nRunByte > 2 )
+            {
+                Scanline pScanline = rAcc.GetScanline(nY);
+                if( bRLE4 )
+                {
+                    nCountByte = nRunByte >> 1;
+
+                    for( sal_uLong i = 0; i < nCountByte; i++ )
+                    {
+                        if (pRLE == pEndRLE)
+                            return false;
+
+                        cTmp = *pRLE++;
+
+                        if( nX < nWidth )
+                            rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp >> 4, rPalette));
+
+                        if( nX < nWidth )
+                            rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp & 0x0f, rPalette));
+                    }
+
+                    if( nRunByte & 1 )
+                    {
+                        if (pRLE == pEndRLE)
+                            return false;
+
+                        if( nX < nWidth )
+                            rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(*pRLE >> 4, rPalette));
+
+                        pRLE++;
+                    }
+
+                    if( ( ( nRunByte + 1 ) >> 1 ) & 1 )
+                    {
+                        if (pRLE == pEndRLE)
+                            return false;
+
+                        pRLE++;
+                    }
+                }
+                else
+                {
+                    for( sal_uLong i = 0; i < nRunByte; i++ )
+                    {
+                        if (pRLE == pEndRLE)
+                            return false;
+
+                        if( nX < nWidth )
+                            rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(*pRLE, rPalette));
+
+                        pRLE++;
+                    }
+
+                    if( nRunByte & 1 )
+                    {
+                        if (pRLE == pEndRLE)
+                            return false;
+
+                        pRLE++;
+                    }
+                }
+            }
+            else if( !nRunByte )
+            {
+                nY--;
+                nX = 0;
+            }
+            else if( nRunByte == 1 )
+                bEndDecoding = true;
+            else
+            {
+                if (pRLE == pEndRLE)
+                    return false;
+
+                nX += *pRLE++;
+
+                if (pRLE == pEndRLE)
+                    return false;
+
+                nY -= *pRLE++;
+            }
+        }
+        else
+        {
+            if (pRLE == pEndRLE)
+                return false;
+            cTmp = *pRLE++;
+
+            Scanline pScanline = rAcc.GetScanline(nY);
+            if( bRLE4 )
+            {
+                nRunByte = nCountByte >> 1;
+
+                for (sal_uLong i = 0; i < nRunByte && nX < nWidth; ++i)
+                {
+                    rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp >> 4, rPalette));
+                    if( nX < nWidth )
+                        rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp & 0x0f, rPalette));
+                }
+
+                if( ( nCountByte & 1 ) && ( nX < nWidth ) )
+                    rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp >> 4, rPalette));
+            }
+            else
+            {
+                for (sal_uLong i = 0; i < nCountByte && nX < nWidth; ++i)
+                    rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp, rPalette));
+            }
+        }
+    }
+    while (!bEndDecoding && (nY >= 0));
+
+    return true;
+}
+
+bool ImplReadDIBBits(SvStream& rIStm, DIBV5Header& rHeader, BitmapWriteAccess& rAcc, BitmapPalette& rPalette, BitmapWriteAccess* pAccAlpha,
+                     bool bTopDown, bool& rAlphaUsed, const sal_uInt64 nAlignedWidth)
+{
+    sal_uInt32 nRMask(( rHeader.nBitCount == 16 ) ? 0x00007c00UL : 0x00ff0000UL);
+    sal_uInt32 nGMask(( rHeader.nBitCount == 16 ) ? 0x000003e0UL : 0x0000ff00UL);
+    sal_uInt32 nBMask(( rHeader.nBitCount == 16 ) ? 0x0000001fUL : 0x000000ffUL);
+    bool bNative(false);
+    bool bTCMask(!pAccAlpha && ((16 == rHeader.nBitCount) || (32 == rHeader.nBitCount)));
+    bool bRLE((RLE_8 == rHeader.nCompression && 8 == rHeader.nBitCount) || (RLE_4 == rHeader.nCompression && 4 == rHeader.nBitCount));
+
+    // Is native format?
+    switch(rAcc.GetScanlineFormat())
+    {
+        case ScanlineFormat::N1BitMsbPal:
+        case ScanlineFormat::N24BitTcBgr:
+        {
+            // we can't trust arbitrary-sourced index based formats to have correct indexes, so we exclude the pal formats
+            // from raw read and force checking their colormap indexes
+            bNative = ( ( rAcc.IsBottomUp() != bTopDown ) && !bRLE && !bTCMask && ( rAcc.GetScanlineSize() == nAlignedWidth ) );
+            break;
+        }
+
+        default:
+        {
+            break;
+        }
+    }
+
+    // Read data
+    if (bNative)
+    {
+        if (nAlignedWidth
+            > std::numeric_limits<std::size_t>::max() / rHeader.nHeight)
+        {
+            return false;
+        }
+        std::size_t n = nAlignedWidth * rHeader.nHeight;
+        if (rIStm.ReadBytes(rAcc.GetBuffer(), n) != n)
+        {
+            return false;
+        }
+    }
+    else
+    {
+        if (rHeader.nV5RedMask > 0)
+            nRMask = rHeader.nV5RedMask;
+        if (rHeader.nV5GreenMask > 0)
+            nGMask = rHeader.nV5GreenMask;
+        if (rHeader.nV5BlueMask > 0)
+            nBMask = rHeader.nV5BlueMask;
+
+        const tools::Long nWidth(rHeader.nWidth);
+        const tools::Long nHeight(rHeader.nHeight);
+        tools::Long nResult = 0;
+        if (utl::ConfigManager::IsFuzzing() && (o3tl::checked_multiply(nWidth, nHeight, nResult) || nResult > 4000000))
+            return false;
+
+        if (bRLE)
+        {
+            if(!rHeader.nSizeImage)
+            {
+                rHeader.nSizeImage = rIStm.remainingSize();
+            }
+
+            if (rHeader.nSizeImage > rIStm.remainingSize())
+                return false;
+            std::vector<sal_uInt8> aBuffer(rHeader.nSizeImage);
+            if (rIStm.ReadBytes(aBuffer.data(), rHeader.nSizeImage) != rHeader.nSizeImage)
+                return false;
+            if (!ImplDecodeRLE(aBuffer.data(), rHeader, rAcc, rPalette, RLE_4 == rHeader.nCompression))
+                return false;
+        }
+        else
+        {
+            if (nAlignedWidth > rIStm.remainingSize())
+            {
+                // ofz#11188 avoid timeout
+                // all following paths will enter a case statement, and nCount
+                // is always at least 1, so we can check here before allocation
+                // if at least one row can be read
+                return false;
+            }
+            std::vector<sal_uInt8> aBuf(nAlignedWidth);
+
+            const tools::Long nI(bTopDown ? 1 : -1);
+            tools::Long nY(bTopDown ? 0 : nHeight - 1);
+            tools::Long nCount(nHeight);
+
+            switch(rHeader.nBitCount)
+            {
+                case 1:
+                {
+                    for( ; nCount--; nY += nI )
+                    {
+                        sal_uInt8 * pTmp = aBuf.data();
+                        if (rIStm.ReadBytes(pTmp, nAlignedWidth)
+                            != nAlignedWidth)
+                        {
+                            return false;
+                        }
+                        sal_uInt8   cTmp = *pTmp++;
+                        Scanline pScanline = rAcc.GetScanline(nY);
+                        for( tools::Long nX = 0, nShift = 8; nX < nWidth; nX++ )
+                        {
+                            if( !nShift )
+                            {
+                                nShift = 8;
+                                cTmp = *pTmp++;
+                            }
+
+                            auto nIndex = (cTmp >> --nShift) & 1;
+                            rAcc.SetPixelOnData(pScanline, nX, SanitizePaletteIndex(nIndex, rPalette));
+                        }
+                    }
+                }
+                break;
+
+                case 4:
+                {
+                    for( ; nCount--; nY += nI )
+                    {
+                        sal_uInt8 * pTmp = aBuf.data();
+                        if (rIStm.ReadBytes(pTmp, nAlignedWidth)
+                            != nAlignedWidth)
+                        {
+                            return false;
+                        }
+                        sal_uInt8   cTmp = *pTmp++;
+                        Scanline pScanline = rAcc.GetScanline(nY);
+                        for( tools::Long nX = 0, nShift = 2; nX < nWidth; nX++ )
+                        {
+                            if( !nShift )
+                            {
+                                nShift = 2;
+                                cTmp = *pTmp++;
+                            }
+
+                            auto nIndex = (cTmp >> ( --nShift << 2 ) ) & 0x0f;
+                            rAcc.SetPixelOnData(pScanline, nX, SanitizePaletteIndex(nIndex, rPalette));
+                        }
+                    }
+                }
+                break;
+
+                case 8:
+                {
+                    for( ; nCount--; nY += nI )
+                    {
+                        sal_uInt8 * pTmp = aBuf.data();
+                        if (rIStm.ReadBytes(pTmp, nAlignedWidth)
+                            != nAlignedWidth)
+                        {
+                            return false;
+                        }
+
+                        Scanline pScanline = rAcc.GetScanline(nY);
+                        for( tools::Long nX = 0; nX < nWidth; nX++ )
+                        {
+                            auto nIndex = *pTmp++;
+                            rAcc.SetPixelOnData(pScanline, nX, SanitizePaletteIndex(nIndex, rPalette));
+                        }
+                    }
+                }
+                break;
+
+                case 16:
+                {
+                    ColorMaskElement aRedMask(nRMask);
+                    if (!aRedMask.CalcMaskShift())
+                        return false;
+                    ColorMaskElement aGreenMask(nGMask);
+                    if (!aGreenMask.CalcMaskShift())
+                        return false;
+                    ColorMaskElement aBlueMask(nBMask);
+                    if (!aBlueMask.CalcMaskShift())
+                        return false;
+
+                    ColorMask   aMask(aRedMask, aGreenMask, aBlueMask);
+                    BitmapColor aColor;
+
+                    for( ; nCount--; nY += nI )
+                    {
+                        sal_uInt16 * pTmp16 = reinterpret_cast<sal_uInt16*>(aBuf.data());
+                        if (rIStm.ReadBytes(pTmp16, nAlignedWidth)
+                            != nAlignedWidth)
+                        {
+                            return false;
+                        }
+
+                        Scanline pScanline = rAcc.GetScanline(nY);
+                        for( tools::Long nX = 0; nX < nWidth; nX++ )
+                        {
+                            aMask.GetColorFor16BitLSB( aColor, reinterpret_cast<sal_uInt8*>(pTmp16++) );
+                            rAcc.SetPixelOnData(pScanline, nX, aColor);
+                        }
+                    }
+                }
+                break;
+
+                case 24:
+                {
+                    BitmapColor aPixelColor;
+
+                    for( ; nCount--; nY += nI )
+                    {
+                        sal_uInt8* pTmp = aBuf.data();
+                        if (rIStm.ReadBytes(pTmp, nAlignedWidth)
+                            != nAlignedWidth)
+                        {
+                            return false;
+                        }
+
+                        Scanline pScanline = rAcc.GetScanline(nY);
+                        for( tools::Long nX = 0; nX < nWidth; nX++ )
+                        {
+                            aPixelColor.SetBlue( *pTmp++ );
+                            aPixelColor.SetGreen( *pTmp++ );
+                            aPixelColor.SetRed( *pTmp++ );
+                            rAcc.SetPixelOnData(pScanline, nX, aPixelColor);
+                        }
+                    }
+                }
+                break;
+
+                case 32:
+                {
+                    ColorMaskElement aRedMask(nRMask);
+                    if (!aRedMask.CalcMaskShift())
+                        return false;
+                    ColorMaskElement aGreenMask(nGMask);
+                    if (!aGreenMask.CalcMaskShift())
+                        return false;
+                    ColorMaskElement aBlueMask(nBMask);
+                    if (!aBlueMask.CalcMaskShift())
+                        return false;
+                    ColorMask aMask(aRedMask, aGreenMask, aBlueMask);
+
+                    BitmapColor aColor;
+                    sal_uInt32* pTmp32;
+
+                    if(pAccAlpha)
+                    {
+                        sal_uInt8 aAlpha;
+
+                        for( ; nCount--; nY += nI )
+                        {
+                            pTmp32 = reinterpret_cast<sal_uInt32*>(aBuf.data());
+                            if (rIStm.ReadBytes(pTmp32, nAlignedWidth)
+                                != nAlignedWidth)
+                            {
+                                return false;
+                            }
+
+                            Scanline pScanline = rAcc.GetScanline(nY);
+                            Scanline pAlphaScanline = pAccAlpha->GetScanline(nY);
+                            for( tools::Long nX = 0; nX < nWidth; nX++ )
+                            {
+                                aMask.GetColorAndAlphaFor32Bit( aColor, aAlpha, reinterpret_cast<sal_uInt8*>(pTmp32++) );
+                                rAcc.SetPixelOnData(pScanline, nX, aColor);
+                                pAccAlpha->SetPixelOnData(pAlphaScanline, nX, BitmapColor(sal_uInt8(0xff) - aAlpha));
+                                rAlphaUsed |= 0xff != aAlpha;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        for( ; nCount--; nY += nI )
+                        {
+                            pTmp32 = reinterpret_cast<sal_uInt32*>(aBuf.data());
+                            if (rIStm.ReadBytes(pTmp32, nAlignedWidth)
+                                != nAlignedWidth)
+                            {
+                                return false;
+                            }
+
+                            Scanline pScanline = rAcc.GetScanline(nY);
+                            for( tools::Long nX = 0; nX < nWidth; nX++ )
+                            {
+                                aMask.GetColorFor32Bit( aColor, reinterpret_cast<sal_uInt8*>(pTmp32++) );
+                                rAcc.SetPixelOnData(pScanline, nX, aColor);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return rIStm.GetError() == ERRCODE_NONE;
+}
+
+bool ImplReadDIBBody(SvStream& rIStm, Bitmap& rBmp, AlphaMask* pBmpAlpha, sal_uInt64 nOffset, bool bMSOFormat)
+{
+    DIBV5Header aHeader;
+    const sal_uInt64 nStmPos = rIStm.Tell();
+    bool bTopDown(false);
+
+    if (!ImplReadDIBInfoHeader(rIStm, aHeader, bTopDown, bMSOFormat))
+        return false;
+
+    //BI_BITCOUNT_0 jpeg/png is unsupported
+    if (aHeader.nBitCount == 0)
+        return false;
+
+    if (aHeader.nWidth <= 0 || aHeader.nHeight <= 0)
+        return false;
+
+    // In case ImplReadDIB() didn't call ImplReadDIBFileHeader() before
+    // this method, nOffset is 0, that's OK.
+    if (nOffset && aHeader.nSize > nOffset)
+    {
+        // Header size claims to extend into the image data.
+        // Looks like an error.
+        return false;
+    }
+
+    sal_uInt16 nColors(0);
+    SvStream* pIStm;
+    std::unique_ptr<SvMemoryStream> pMemStm;
+    std::vector<sal_uInt8> aData;
+
+    if (aHeader.nBitCount <= 8)
+    {
+        if(aHeader.nColsUsed)
+        {
+            nColors = static_cast<sal_uInt16>(aHeader.nColsUsed);
+        }
+        else
+        {
+            nColors = ( 1 << aHeader.nBitCount );
+        }
+    }
+
+    if (ZCOMPRESS == aHeader.nCompression)
+    {
+        sal_uInt32 nCodedSize(0);
+        sal_uInt32  nUncodedSize(0);
+
+        // read coding information
+        rIStm.ReadUInt32( nCodedSize ).ReadUInt32( nUncodedSize ).ReadUInt32( aHeader.nCompression );
+        if (nCodedSize > rIStm.remainingSize())
+           nCodedSize = sal_uInt32(rIStm.remainingSize());
+
+        pMemStm.reset(new SvMemoryStream);
+        // There may be bytes left over or the codec might read more than
+        // necessary. So to preserve the correctness of the source stream copy
+        // the encoded block
+        pMemStm->WriteStream(rIStm, nCodedSize);
+        pMemStm->Seek(0);
+
+        size_t nSizeInc(4 * pMemStm->remainingSize());
+        if (nUncodedSize < nSizeInc)
+            nSizeInc = nUncodedSize;
+
+        if (nSizeInc > 0)
+        {
+            // decode buffer
+            ZCodec aCodec;
+            aCodec.BeginCompression();
+            aData.resize(nSizeInc);
+            size_t nDataPos(0);
+            while (nUncodedSize > nDataPos)
+            {
+                assert(aData.size() > nDataPos);
+                const size_t nToRead(std::min<size_t>(nUncodedSize - nDataPos, aData.size() - nDataPos));
+                assert(nToRead > 0);
+                assert(!aData.empty());
+                const tools::Long nRead = aCodec.Read(*pMemStm, aData.data() + nDataPos, sal_uInt32(nToRead));
+                if (nRead > 0)
+                {
+                    nDataPos += static_cast<tools::ULong>(nRead);
+                    // we haven't read everything yet: resize buffer and continue
+                    if (nDataPos < nUncodedSize)
+                        aData.resize(aData.size() + nSizeInc);
+                }
+                else
+                {
+                    break;
+                }
+            }
+            // truncate the data buffer to actually read size
+            aData.resize(nDataPos);
+            // set the real uncoded size
+            nUncodedSize = sal_uInt32(aData.size());
+            aCodec.EndCompression();
+        }
+
+        if (aData.empty())
+        {
+            // add something so we can take address of the first element
+            aData.resize(1);
+            nUncodedSize = 0;
+        }
+
+        // set decoded bytes to memory stream,
+        // from which we will read the bitmap data
+        pMemStm.reset(new SvMemoryStream);
+        pIStm = pMemStm.get();
+        assert(!aData.empty());
+        pMemStm->SetBuffer(aData.data(), nUncodedSize, nUncodedSize);
+        nOffset = 0;
+    }
+    else
+    {
+        pIStm = &rIStm;
+    }
+
+    // read palette
+    BitmapPalette aPalette;
+    if (nColors)
+    {
+        aPalette.SetEntryCount(nColors);
+        ImplReadDIBPalette(*pIStm, aPalette, aHeader.nSize != DIBCOREHEADERSIZE);
+    }
+
+    if (pIStm->GetError())
+        return false;
+
+    if (nOffset)
+    {
+        // It is problematic to seek backwards. We are at the
+        // end of BITMAPINFOHEADER or 12 bytes further in case
+        // of WinBMPv3-NT format. It is possible to seek forward
+        // though because a gap may be there.
+        sal_Int64 nSeekRel = nOffset - (pIStm->Tell() - nStmPos);
+        if (nSeekRel > 0)
+            pIStm->SeekRel(nSeekRel);
+    }
+
+    const sal_Int64 nBitsPerLine (static_cast<sal_Int64>(aHeader.nWidth) * static_cast<sal_Int64>(aHeader.nBitCount));
+    if (nBitsPerLine > SAL_MAX_UINT32)
+        return false;
+    const sal_uInt64 nAlignedWidth(AlignedWidth4Bytes(static_cast<sal_uLong>(nBitsPerLine)));
+
+    switch (aHeader.nCompression)
+    {
+        case RLE_8:
+        {
+            if (aHeader.nBitCount != 8)
+                return false;
+            // (partially) check the image dimensions to avoid potential large bitmap allocation if the input is damaged
+            sal_uInt64 nMaxWidth = pIStm->remainingSize();
+            nMaxWidth *= 256;   //assume generous compression ratio
+            nMaxWidth /= aHeader.nHeight;
+            if (nMaxWidth < o3tl::make_unsigned(aHeader.nWidth))
+                return false;
+            break;
+        }
+        case RLE_4:
+        {
+            if (aHeader.nBitCount != 4)
+                return false;
+            sal_uInt64 nMaxWidth = pIStm->remainingSize();
+            nMaxWidth *= 512;   //assume generous compression ratio
+            nMaxWidth /= aHeader.nHeight;
+            if (nMaxWidth < o3tl::make_unsigned(aHeader.nWidth))
+                return false;
+            break;
+        }
+        default:
+            // tdf#122958 invalid compression value used
+            if (aHeader.nCompression & 0x000F)
+            {
+                // lets assume that there was an error in the generating application
+                // and allow through as COMPRESS_NONE if the bottom byte is 0
+                SAL_WARN( "vcl", "bad bmp compression scheme: " << aHeader.nCompression << ", rejecting bmp");
+                return false;
+            }
+            else
+                SAL_WARN( "vcl", "bad bmp compression scheme: " << aHeader.nCompression << ", assuming meant to be COMPRESS_NONE");
+        [[fallthrough]];
+        case BITFIELDS:
+        case ZCOMPRESS:
+        case COMPRESS_NONE:
+        {
+            // (partially) check the image dimensions to avoid potential large bitmap allocation if the input is damaged
+            sal_uInt64 nMaxWidth = pIStm->remainingSize();
+            nMaxWidth /= aHeader.nHeight;
+            if (nMaxWidth < nAlignedWidth)
+                return false;
+            break;
+        }
+    }
+
+    const Size aSizePixel(aHeader.nWidth, aHeader.nHeight);
+    AlphaMask aNewBmpAlpha;
+    BitmapScopedWriteAccess pAccAlpha;
+    bool bAlphaPossible(pBmpAlpha && aHeader.nBitCount == 32);
+
+    if (bAlphaPossible)
+    {
+        const bool bRedSet(0 != aHeader.nV5RedMask);
+        const bool bGreenSet(0 != aHeader.nV5GreenMask);
+        const bool bBlueSet(0 != aHeader.nV5BlueMask);
+
+        // some clipboard entries have alpha mask on zero to say that there is
+        // no alpha; do only use this when the other masks are set. The MS docu
+        // says that masks are only to be set when bV5Compression is set to
+        // BI_BITFIELDS, but there seem to exist a wild variety of usages...
+        if((bRedSet || bGreenSet || bBlueSet) && (0 == aHeader.nV5AlphaMask))
+        {
+            bAlphaPossible = false;
+        }
+    }
+
+    if (bAlphaPossible)
+    {
+        aNewBmpAlpha = AlphaMask(aSizePixel);
+        pAccAlpha = aNewBmpAlpha;
+    }
+
+    vcl::PixelFormat ePixelFormat(convertToBPP(aHeader.nBitCount));
+    const BitmapPalette* pPal = &aPalette;
+    //ofz#948 match the surrounding logic of case TransparentType::Bitmap of
+    //ReadDIBBitmapEx but do it while reading for performance
+
+    Bitmap aNewBmp(aSizePixel, ePixelFormat, pPal);
+    BitmapScopedWriteAccess pAcc(aNewBmp);
+    if (!pAcc)
+        return false;
+    if (pAcc->Width() != aHeader.nWidth || pAcc->Height() != aHeader.nHeight)
+    {
+        return false;
+    }
+
+    // read bits
+    bool bAlphaUsed(false);
+    bool bRet = ImplReadDIBBits(*pIStm, aHeader, *pAcc, aPalette, pAccAlpha.get(), bTopDown, bAlphaUsed, nAlignedWidth);
+
+    if (bRet && aHeader.nXPelsPerMeter && aHeader.nYPelsPerMeter)
+    {
+        MapMode aMapMode(
+            MapUnit::MapMM,
+            Point(),
+            Fraction(1000, aHeader.nXPelsPerMeter),
+            Fraction(1000, aHeader.nYPelsPerMeter));
+
+        aNewBmp.SetPrefMapMode(aMapMode);
+        aNewBmp.SetPrefSize(Size(aHeader.nWidth, aHeader.nHeight));
+    }
+
+    pAcc.reset();
+
+    if (bAlphaPossible)
+    {
+        pAccAlpha.reset();
+
+        if(!bAlphaUsed)
+        {
+            bAlphaPossible = false;
+        }
+    }
+
+    if (bRet)
+    {
+        rBmp = aNewBmp;
+
+        if(bAlphaPossible)
+        {
+            *pBmpAlpha = aNewBmpAlpha;
+        }
+    }
+
+    return bRet;
+}
+
+bool ImplReadDIBFileHeader( SvStream& rIStm, sal_uLong& rOffset )
+{
+    bool bRet = false;
+
+    const sal_uInt64 nStreamLength = rIStm.TellEnd();
+
+    sal_uInt16 nTmp16 = 0;
+    rIStm.ReadUInt16( nTmp16 );
+
+    if ( ( 0x4D42 == nTmp16 ) || ( 0x4142 == nTmp16 ) )
+    {
+        sal_uInt32 nTmp32(0);
+        if ( 0x4142 == nTmp16 )
+        {
+            rIStm.SeekRel( 12 );
+            rIStm.ReadUInt16( nTmp16 );
+            rIStm.SeekRel( 8 );
+            rIStm.ReadUInt32( nTmp32 );
+            rOffset = nTmp32 - 28;
+            bRet = ( 0x4D42 == nTmp16 );
+        }
+        else // 0x4D42 == nTmp16, 'MB' from BITMAPFILEHEADER
+        {
+            rIStm.SeekRel( 8 );        // we are on bfSize member of BITMAPFILEHEADER, forward to bfOffBits
+            rIStm.ReadUInt32( nTmp32 );            // read bfOffBits
+            rOffset = nTmp32 - 14;    // adapt offset by sizeof(BITMAPFILEHEADER)
+            bRet = rIStm.GetError() == ERRCODE_NONE;
+        }
+
+        if ( rOffset >= nStreamLength )
+        {
+            // Offset claims that image starts past the end of the
+            // stream.  Unlikely.
+            rIStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
+            bRet = false;
+        }
+    }
+    else
+        rIStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
+
+    return bRet;
+}
+
+bool ImplWriteDIBPalette( SvStream& rOStm, BitmapReadAccess const & rAcc )
+{
+    const sal_uInt16    nColors = rAcc.GetPaletteEntryCount();
+    const sal_uLong     nPalSize = nColors * 4UL;
+    std::unique_ptr<sal_uInt8[]> pEntries(new sal_uInt8[ nPalSize ]);
+    sal_uInt8*          pTmpEntry = pEntries.get();
+
+    for( sal_uInt16 i = 0; i < nColors; i++ )
+    {
+        const BitmapColor& rPalColor = rAcc.GetPaletteColor( i );
+
+        *pTmpEntry++ = rPalColor.GetBlue();
+        *pTmpEntry++ = rPalColor.GetGreen();
+        *pTmpEntry++ = rPalColor.GetRed();
+        *pTmpEntry++ = 0;
+    }
+
+    rOStm.WriteBytes( pEntries.get(), nPalSize );
+
+    return rOStm.GetError() == ERRCODE_NONE;
+}
+
+bool ImplWriteRLE( SvStream& rOStm, BitmapReadAccess const & rAcc, bool bRLE4 )
+{
+    const sal_uLong nWidth = rAcc.Width();
+    const sal_uLong nHeight = rAcc.Height();
+    sal_uLong       nX;
+    sal_uLong       nSaveIndex;
+    sal_uLong       nCount;
+    sal_uLong       nBufCount;
+    std::vector<sal_uInt8> aBuf(( nWidth << 1 ) + 2);
+    sal_uInt8       cPix;
+    sal_uInt8       cLast;
+    bool        bFound;
+
+    for ( tools::Long nY = nHeight - 1; nY >= 0; nY-- )
+    {
+        sal_uInt8* pTmp = aBuf.data();
+        nX = nBufCount = 0;
+        Scanline pScanline = rAcc.GetScanline( nY );
+
+        while( nX < nWidth )
+        {
+            nCount = 1;
+            cPix = rAcc.GetIndexFromData( pScanline, nX++ );
+
+            while( ( nX < nWidth ) && ( nCount < 255 )
+                && ( cPix == rAcc.GetIndexFromData( pScanline, nX ) ) )
+            {
+                nX++;
+                nCount++;
+            }
+
+            if ( nCount > 1 )
+            {
+                *pTmp++ = static_cast<sal_uInt8>(nCount);
+                *pTmp++ = ( bRLE4 ? ( ( cPix << 4 ) | cPix ) : cPix );
+                nBufCount += 2;
+            }
+            else
+            {
+                cLast = cPix;
+                nSaveIndex = nX - 1;
+                bFound = false;
+
+                while( ( nX < nWidth ) && ( nCount < 256 ) )
+                {
+                    cPix = rAcc.GetIndexFromData( pScanline, nX );
+                    if (cPix == cLast)
+                        break;
+                    nX++; nCount++;
+                    cLast = cPix;
+                    bFound = true;
+                }
+
+                if ( bFound )
+                    nX--;
+
+                if ( nCount > 3 )
+                {
+                    *pTmp++ = 0;
+                    *pTmp++ = static_cast<sal_uInt8>(--nCount);
+
+                    if( bRLE4 )
+                    {
+                        for ( sal_uLong i = 0; i < nCount; i++, pTmp++ )
+                        {
+                            *pTmp = rAcc.GetIndexFromData( pScanline, nSaveIndex++ ) << 4;
+
+                            if ( ++i < nCount )
+                                *pTmp |= rAcc.GetIndexFromData( pScanline, nSaveIndex++ );
+                        }
+
+                        nCount = ( nCount + 1 ) >> 1;
+                    }
+                    else
+                    {
+                        for( sal_uLong i = 0; i < nCount; i++ )
+                            *pTmp++ = rAcc.GetIndexFromData( pScanline, nSaveIndex++ );
+                    }
+
+                    if ( nCount & 1 )
+                    {
+                        *pTmp++ = 0;
+                        nBufCount += ( nCount + 3 );
+                    }
+                    else
+                        nBufCount += ( nCount + 2 );
+                }
+                else
+                {
+                    *pTmp++ = 1;
+                    *pTmp++ = rAcc.GetIndexFromData( pScanline, nSaveIndex ) << (bRLE4 ? 4 : 0);
+
+                    if ( nCount == 3 )
+                    {
+                        *pTmp++ = 1;
+                        *pTmp++ = rAcc.GetIndexFromData( pScanline, ++nSaveIndex ) << ( bRLE4 ? 4 : 0 );
+                        nBufCount += 4;
+                    }
+                    else
+                        nBufCount += 2;
+                }
+            }
+        }
+
+        aBuf[ nBufCount++ ] = 0;
+        aBuf[ nBufCount++ ] = 0;
+
+        rOStm.WriteBytes(aBuf.data(), nBufCount);
+    }
+
+    rOStm.WriteUChar( 0 );
+    rOStm.WriteUChar( 1 );
+
+    return rOStm.GetError() == ERRCODE_NONE;
+}
+
+bool ImplWriteDIBBits(SvStream& rOStm, BitmapReadAccess const & rAcc, sal_uLong nCompression, sal_uInt32& rImageSize)
+{
+    if(BITFIELDS == nCompression)
+    {
+        const ColorMask&    rMask = rAcc.GetColorMask();
+        SVBT32              aVal32;
+
+        UInt32ToSVBT32( rMask.GetRedMask(), aVal32 );
+        rOStm.WriteBytes( aVal32, 4UL );
+
+        UInt32ToSVBT32( rMask.GetGreenMask(), aVal32 );
+        rOStm.WriteBytes( aVal32, 4UL );
+
+        UInt32ToSVBT32( rMask.GetBlueMask(), aVal32 );
+        rOStm.WriteBytes( aVal32, 4UL );
+
+        rImageSize = rOStm.Tell();
+
+        if( rAcc.IsBottomUp() )
+            rOStm.WriteBytes(rAcc.GetBuffer(), rAcc.Height() * rAcc.GetScanlineSize());
+        else
+        {
+            for( tools::Long nY = rAcc.Height() - 1, nScanlineSize = rAcc.GetScanlineSize(); nY >= 0; nY-- )
+                rOStm.WriteBytes( rAcc.GetScanline(nY), nScanlineSize );
+        }
+    }
+    else if((RLE_4 == nCompression) || (RLE_8 == nCompression))
+    {
+        rImageSize = rOStm.Tell();
+        ImplWriteRLE( rOStm, rAcc, RLE_4 == nCompression );
+    }
+    else if(!nCompression)
+    {
+        // #i5xxx# Limit bitcount to 24bit, the 32 bit cases are not
+        // handled properly below (would have to set color masks, and
+        // nCompression=BITFIELDS - but color mask is not set for
+        // formats != *_TC_*). Note that this very problem might cause
+        // trouble at other places - the introduction of 32 bit RGBA
+        // bitmaps is relatively recent.
+        // #i59239# discretize bitcount for aligned width to 1,8,24
+        // (other cases are not written below)
+        const auto ePixelFormat(convertToBPP(rAcc.GetBitCount()));
+        const sal_uLong nAlignedWidth(AlignedWidth4Bytes(rAcc.Width() * sal_Int32(ePixelFormat)));
+        bool bNative(false);
+
+        switch(rAcc.GetScanlineFormat())
+        {
+            case ScanlineFormat::N1BitMsbPal:
+            case ScanlineFormat::N8BitPal:
+            case ScanlineFormat::N24BitTcBgr:
+            {
+                if(rAcc.IsBottomUp() && (rAcc.GetScanlineSize() == nAlignedWidth))
+                {
+                    bNative = true;
+                }
+
+                break;
+            }
+
+            default:
+            {
+                break;
+            }
+        }
+
+        rImageSize = rOStm.Tell();
+
+        if(bNative)
+        {
+            rOStm.WriteBytes(rAcc.GetBuffer(), nAlignedWidth * rAcc.Height());
+        }
+        else
+        {
+            const tools::Long nWidth(rAcc.Width());
+            const tools::Long nHeight(rAcc.Height());
+            std::vector<sal_uInt8> aBuf(nAlignedWidth);
+            switch(ePixelFormat)
+            {
+                case vcl::PixelFormat::N8_BPP:
+                {
+                    for( tools::Long nY = nHeight - 1; nY >= 0; nY-- )
+                    {
+                        sal_uInt8* pTmp = aBuf.data();
+                        Scanline pScanline = rAcc.GetScanline( nY );
+
+                        for( tools::Long nX = 0; nX < nWidth; nX++ )
+                            *pTmp++ = rAcc.GetIndexFromData( pScanline, nX );
+
+                        rOStm.WriteBytes(aBuf.data(), nAlignedWidth);
+                    }
+                }
+                break;
+
+                case vcl::PixelFormat::N24_BPP:
+                {
+                    //valgrind, zero out the trailing unused alignment bytes
+                    size_t nUnusedBytes = nAlignedWidth - nWidth * 3;
+                    memset(aBuf.data() + nAlignedWidth - nUnusedBytes, 0, nUnusedBytes);
+                }
+                [[fallthrough]];
+                // #i59239# fallback to 24 bit format, if bitcount is non-default
+                default:
+                {
+                    BitmapColor aPixelColor;
+
+                    for( tools::Long nY = nHeight - 1; nY >= 0; nY-- )
+                    {
+                        sal_uInt8* pTmp = aBuf.data();
+
+                        for( tools::Long nX = 0; nX < nWidth; nX++ )
+                        {
+                            // when alpha is used, this may be non-24bit main bitmap, so use GetColor
+                            // instead of GetPixel to ensure RGB value
+                            aPixelColor = rAcc.GetColor( nY, nX );
+
+                            *pTmp++ = aPixelColor.GetBlue();
+                            *pTmp++ = aPixelColor.GetGreen();
+                            *pTmp++ = aPixelColor.GetRed();
+                        }
+
+                        rOStm.WriteBytes(aBuf.data(), nAlignedWidth);
+                    }
+                }
+                break;
+            }
+        }
+    }
+
+    rImageSize = rOStm.Tell() - rImageSize;
+
+    return (!rOStm.GetError());
+}
+
+bool ImplWriteDIBBody(const Bitmap& rBitmap, SvStream& rOStm, BitmapReadAccess const & rAcc, bool bCompressed)
+{
+    const MapMode aMapPixel(MapUnit::MapPixel);
+    DIBV5Header aHeader;
+    sal_uInt64 nImageSizePos(0);
+    sal_uInt64 nEndPos(0);
+    sal_uInt32 nCompression(COMPRESS_NONE);
+    bool bRet(false);
+
+    aHeader.nSize = DIBINFOHEADERSIZE; // size dependent on CF_DIB type to use
+    aHeader.nWidth = rAcc.Width();
+    aHeader.nHeight = rAcc.Height();
+    aHeader.nPlanes = 1;
+
+    if(isBitfieldCompression(rAcc.GetScanlineFormat()))
+    {
+        aHeader.nBitCount = 32;
+        aHeader.nSizeImage = rAcc.Height() * rAcc.GetScanlineSize();
+        nCompression = BITFIELDS;
+    }
+    else
+    {
+        // #i5xxx# Limit bitcount to 24bit, the 32 bit cases are
+        // not handled properly below (would have to set color
+        // masks, and nCompression=BITFIELDS - but color mask is
+        // not set for formats != *_TC_*). Note that this very
+        // problem might cause trouble at other places - the
+        // introduction of 32 bit RGBA bitmaps is relatively
+        // recent.
+        // #i59239# discretize bitcount to 1,8,24 (other cases
+        // are not written below)
+        const auto ePixelFormat(convertToBPP(rAcc.GetBitCount()));
+        aHeader.nBitCount = sal_uInt16(ePixelFormat);
+        aHeader.nSizeImage = rAcc.Height() * AlignedWidth4Bytes(rAcc.Width() * aHeader.nBitCount);
+
+        if (bCompressed)
+        {
+            if (ePixelFormat == vcl::PixelFormat::N8_BPP)
+                nCompression = RLE_8;
+        }
+    }
+
+    if((rOStm.GetCompressMode() & SvStreamCompressFlags::ZBITMAP) && (rOStm.GetVersion() >= SOFFICE_FILEFORMAT_40))
+    {
+        aHeader.nCompression = ZCOMPRESS;
+    }
+    else
+    {
+        aHeader.nCompression = nCompression;
+    }
+
+    if(rBitmap.GetPrefSize().Width() && rBitmap.GetPrefSize().Height() && (rBitmap.GetPrefMapMode() != aMapPixel))
+    {
+        // #i48108# Try to recover xpels/ypels as previously stored on
+        // disk. The problem with just converting maPrefSize to 100th
+        // mm and then relating that to the bitmap pixel size is that
+        // MapMode is integer-based, and suffers from roundoffs,
+        // especially if maPrefSize is small. Trying to circumvent
+        // that by performing part of the math in floating point.
+        const Size aScale100000(OutputDevice::LogicToLogic(Size(100000, 100000), MapMode(MapUnit::Map100thMM), rBitmap.GetPrefMapMode()));
+        const double fBmpWidthM(static_cast<double>(rBitmap.GetPrefSize().Width()) / aScale100000.Width());
+        const double fBmpHeightM(static_cast<double>(rBitmap.GetPrefSize().Height()) / aScale100000.Height());
+
+        if(!basegfx::fTools::equalZero(fBmpWidthM) && !basegfx::fTools::equalZero(fBmpHeightM))
+        {
+            aHeader.nXPelsPerMeter = basegfx::fround(rAcc.Width() / fabs(fBmpWidthM));
+            aHeader.nYPelsPerMeter = basegfx::fround(rAcc.Height() / fabs(fBmpHeightM));
+        }
+    }
+
+    aHeader.nColsUsed = ((aHeader.nBitCount <= 8) ? rAcc.GetPaletteEntryCount() : 0);
+    aHeader.nColsImportant = 0;
+
+    rOStm.WriteUInt32( aHeader.nSize );
+    rOStm.WriteInt32( aHeader.nWidth );
+    rOStm.WriteInt32( aHeader.nHeight );
+    rOStm.WriteUInt16( aHeader.nPlanes );
+    rOStm.WriteUInt16( aHeader.nBitCount );
+    rOStm.WriteUInt32( aHeader.nCompression );
+
+    nImageSizePos = rOStm.Tell();
+    rOStm.SeekRel( sizeof( aHeader.nSizeImage ) );
+
+    rOStm.WriteInt32( aHeader.nXPelsPerMeter );
+    rOStm.WriteInt32( aHeader.nYPelsPerMeter );
+    rOStm.WriteUInt32( aHeader.nColsUsed );
+    rOStm.WriteUInt32( aHeader.nColsImportant );
+
+    if(ZCOMPRESS == aHeader.nCompression)
+    {
+        ZCodec aCodec;
+        SvMemoryStream aMemStm(aHeader.nSizeImage + 4096, 65535);
+        sal_uInt64 nCodedPos(rOStm.Tell());
+        sal_uInt64 nLastPos(0);
+        sal_uInt32 nCodedSize(0);
+        sal_uInt32 nUncodedSize(0);
+
+        // write uncoded data palette
+        if(aHeader.nColsUsed)
+        {
+            ImplWriteDIBPalette(aMemStm, rAcc);
+        }
+
+        // write uncoded bits
+        bRet = ImplWriteDIBBits(aMemStm, rAcc, nCompression, aHeader.nSizeImage);
+
+        // get uncoded size
+        nUncodedSize = aMemStm.Tell();
+
+        // seek over compress info
+        rOStm.SeekRel(12);
+
+        // write compressed data
+        aCodec.BeginCompression(3);
+        aCodec.Write(rOStm, static_cast<sal_uInt8 const *>(aMemStm.GetData()), nUncodedSize);
+        aCodec.EndCompression();
+
+        // update compress info ( coded size, uncoded size, uncoded compression )
+        nLastPos = rOStm.Tell();
+        nCodedSize = nLastPos - nCodedPos - 12;
+        rOStm.Seek(nCodedPos);
+        rOStm.WriteUInt32( nCodedSize ).WriteUInt32( nUncodedSize ).WriteUInt32( nCompression );
+        rOStm.Seek(nLastPos);
+
+        if(bRet)
+        {
+            bRet = (ERRCODE_NONE == rOStm.GetError());
+        }
+    }
+    else
+    {
+        if(aHeader.nColsUsed)
+        {
+            ImplWriteDIBPalette(rOStm, rAcc);
+        }
+
+        bRet = ImplWriteDIBBits(rOStm, rAcc, aHeader.nCompression, aHeader.nSizeImage);
+    }
+
+    nEndPos = rOStm.Tell();
+    rOStm.Seek(nImageSizePos);
+    rOStm.WriteUInt32( aHeader.nSizeImage );
+    rOStm.Seek(nEndPos);
+
+    return bRet;
+}
+
+bool ImplWriteDIBFileHeader(SvStream& rOStm, BitmapReadAccess const & rAcc)
+{
+    const sal_uInt32 nPalCount((rAcc.HasPalette() ? rAcc.GetPaletteEntryCount() : isBitfieldCompression(rAcc.GetScanlineFormat()) ? 3UL : 0UL));
+    const sal_uInt32 nOffset(14 + DIBINFOHEADERSIZE + nPalCount * 4UL);
+
+    rOStm.WriteUInt16( 0x4D42 ); // 'MB' from BITMAPFILEHEADER
+    rOStm.WriteUInt32( nOffset + (rAcc.Height() * rAcc.GetScanlineSize()) );
+    rOStm.WriteUInt16( 0 );
+    rOStm.WriteUInt16( 0 );
+    rOStm.WriteUInt32( nOffset );
+
+    return rOStm.GetError() == ERRCODE_NONE;
+}
+
+bool ImplReadDIB(
+    Bitmap& rTarget,
+    AlphaMask* pTargetAlpha,
+    SvStream& rIStm,
+    bool bFileHeader,
+    bool bMSOFormat=false)
+{
+    const SvStreamEndian nOldFormat(rIStm.GetEndian());
+    const auto nOldPos(rIStm.Tell());
+    sal_uLong nOffset(0);
+    bool bRet(false);
+
+    rIStm.SetEndian(SvStreamEndian::LITTLE);
+
+    if(bFileHeader)
+    {
+        if(ImplReadDIBFileHeader(rIStm, nOffset))
+        {
+            bRet = ImplReadDIBBody(rIStm, rTarget, nOffset >= DIBV5HEADERSIZE ? pTargetAlpha : nullptr, nOffset, bMSOFormat);
+        }
+    }
+    else
+    {
+        bRet = ImplReadDIBBody(rIStm, rTarget, nullptr, nOffset, bMSOFormat);
+    }
+
+    if(!bRet)
+    {
+        if(!rIStm.GetError()) // Set error and stop processing whole stream due to security reason
+        {
+            rIStm.SetError(SVSTREAM_GENERALERROR);
+        }
+
+        rIStm.Seek(nOldPos);
+    }
+
+    rIStm.SetEndian(nOldFormat);
+
+    return bRet;
+}
+
+bool ImplWriteDIB(
+    const Bitmap& rSource,
+    SvStream& rOStm,
+    bool bCompressed,
+    bool bFileHeader)
+{
+    const Size aSizePix(rSource.GetSizePixel());
+    bool bRet(false);
+
+    if(!aSizePix.Width() || !aSizePix.Height())
+        return false;
+
+    BitmapScopedReadAccess pAcc(rSource);
+    const SvStreamEndian nOldFormat(rOStm.GetEndian());
+    const sal_uInt64 nOldPos(rOStm.Tell());
+
+    rOStm.SetEndian(SvStreamEndian::LITTLE);
+
+    if (pAcc)
+    {
+        if(bFileHeader)
+        {
+            if(ImplWriteDIBFileHeader(rOStm, *pAcc))
+            {
+                bRet = ImplWriteDIBBody(rSource, rOStm, *pAcc, bCompressed);
+            }
+        }
+        else
+        {
+            bRet = ImplWriteDIBBody(rSource, rOStm, *pAcc, bCompressed);
+        }
+
+        pAcc.reset();
+    }
+
+    if(!bRet)
+    {
+        rOStm.SetError(SVSTREAM_GENERALERROR);
+        rOStm.Seek(nOldPos);
+    }
+
+    rOStm.SetEndian(nOldFormat);
+
+    return bRet;
+}
+
+} // unnamed namespace
+
+bool ReadDIB(
+    Bitmap& rTarget,
+    SvStream& rIStm,
+    bool bFileHeader,
+    bool bMSOFormat)
+{
+    return ImplReadDIB(rTarget, nullptr, rIStm, bFileHeader, bMSOFormat);
+}
+
+bool ReadDIBBitmapEx(
+    BitmapEx& rTarget,
+    SvStream& rIStm,
+    bool bFileHeader,
+    bool bMSOFormat)
+{
+    Bitmap aBmp;
+    bool bRetval(ImplReadDIB(aBmp, nullptr, rIStm, bFileHeader, bMSOFormat) && !rIStm.GetError());
+
+    if(bRetval)
+    {
+        // base bitmap was read, set as return value and try to read alpha extra-data
+        const sal_uInt64 nStmPos(rIStm.Tell());
+        sal_uInt32 nMagic1(0);
+        sal_uInt32 nMagic2(0);
+
+        rTarget = BitmapEx(aBmp);
+        if (rIStm.remainingSize() >= 4)
+            rIStm.ReadUInt32( nMagic1 ).ReadUInt32( nMagic2 );
+        bRetval = (0x25091962 == nMagic1) && (0xACB20201 == nMagic2) && !rIStm.GetError();
+
+        if(bRetval)
+        {
+            sal_uInt8 tmp = 0;
+            rIStm.ReadUChar( tmp );
+            bRetval = !rIStm.GetError();
+
+            if(bRetval)
+            {
+                switch (tmp)
+                {
+                case 2: // TransparentType::Bitmap
+                    {
+                        Bitmap aMask;
+
+                        bRetval = ImplReadDIB(aMask, nullptr, rIStm, true);
+
+                        if(bRetval && !aMask.IsEmpty())
+                            rTarget = BitmapEx(aBmp, aMask);
+
+                        break;
+                    }
+                case 1: // backwards compat for old option TransparentType::Color
+                    {
+                        Color aTransparentColor;
+
+                        tools::GenericTypeSerializer aSerializer(rIStm);
+                        aSerializer.readColor(aTransparentColor);
+
+                        bRetval = rIStm.good();
+
+                        if(bRetval)
+                        {
+                            rTarget = BitmapEx(aBmp, aTransparentColor);
+                        }
+                        break;
+                    }
+                default: break;
+                }
+            }
+        }
+
+        if(!bRetval)
+        {
+            // alpha extra data could not be read; reset, but use base bitmap as result
+            rIStm.ResetError();
+            rIStm.Seek(nStmPos);
+            bRetval = true;
+        }
+    }
+
+    return bRetval;
+}
+
+bool ReadDIBV5(
+    Bitmap& rTarget,
+    AlphaMask& rTargetAlpha,
+    SvStream& rIStm)
+{
+    bool rv = ImplReadDIB(rTarget, &rTargetAlpha, rIStm, true);
+    // convert transparency->alpha
+    if (rv)
+        rTargetAlpha.Invert();
+    return rv;
+}
+
+bool ReadRawDIB(
+    BitmapEx& rTarget,
+    const unsigned char* pBuf,
+    const ScanlineFormat nFormat,
+    const int nHeight,
+    const int nStride)
+{
+    BitmapScopedWriteAccess pWriteAccess(rTarget.maBitmap);
+    for (int nRow = 0; nRow < nHeight; ++nRow)
+    {
+        pWriteAccess->CopyScanline(nRow, pBuf + (nStride * nRow), nFormat, nStride);
+    }
+
+    return true;
+}
+
+bool WriteDIB(
+    const Bitmap& rSource,
+    SvStream& rOStm,
+    bool bCompressed,
+    bool bFileHeader)
+{
+    return ImplWriteDIB(rSource, rOStm, bCompressed, bFileHeader);
+}
+
+bool WriteDIB(
+    const BitmapEx& rSource,
+    SvStream& rOStm,
+    bool bCompressed)
+{
+    return ImplWriteDIB(rSource.GetBitmap(), rOStm, bCompressed, /*bFileHeader*/true);
+}
+
+bool WriteDIBBitmapEx(
+    const BitmapEx& rSource,
+    SvStream& rOStm)
+{
+    if(ImplWriteDIB(rSource.GetBitmap(), rOStm, true, true))
+    {
+        rOStm.WriteUInt32( 0x25091962 );
+        rOStm.WriteUInt32( 0xACB20201 );
+        rOStm.WriteUChar( rSource.IsAlpha() ? 2 : 0 ); // Used to be TransparentType enum
+
+        if(rSource.IsAlpha())
+        {
+            // invert the alpha because the other routines actually want transparency
+            AlphaMask tmpAlpha = rSource.maAlphaMask;
+            tmpAlpha.Invert();
+            return ImplWriteDIB(tmpAlpha.GetBitmap(), rOStm, true, true);
+        }
+    }
+
+    return false;
+}
+
+sal_uInt32 getDIBV5HeaderSize()
+{
+    return DIBV5HEADERSIZE;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/floyd.hxx b/vcl/source/bitmap/floyd.hxx
new file mode 100644
index 0000000000..b5f26fb7a6
--- /dev/null
+++ b/vcl/source/bitmap/floyd.hxx
@@ -0,0 +1,177 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#pragma once
+
+const extern sal_uLong nVCLRLut[ 6 ] = { 16, 17, 18, 19, 20, 21 };
+const extern sal_uLong nVCLGLut[ 6 ] = { 0, 6, 12, 18, 24, 30 };
+const extern sal_uLong nVCLBLut[ 6 ] = { 0, 36, 72, 108, 144, 180 };
+
+const extern sal_uLong nVCLDitherLut[ 256 ] =
+{
+       0, 49152, 12288, 61440,  3072, 52224, 15360, 64512,   768, 49920, 13056,
+   62208,  3840, 52992, 16128, 65280, 32768, 16384, 45056, 28672, 35840, 19456,
+   48128, 31744, 33536, 17152, 45824, 29440, 36608, 20224, 48896, 32512, 8192,
+   57344,  4096, 53248, 11264, 60416,  7168, 56320,  8960, 58112,  4864, 54016,
+   12032, 61184,  7936, 57088, 40960, 24576, 36864, 20480, 44032, 27648, 39936,
+   23552, 41728, 25344, 37632, 21248, 44800, 28416, 40704, 24320, 2048, 51200,
+   14336, 63488,  1024, 50176, 13312, 62464,  2816, 51968, 15104, 64256,  1792,
+   50944, 14080, 63232, 34816, 18432, 47104, 30720, 33792, 17408, 46080, 29696,
+   35584, 19200, 47872, 31488, 34560, 18176, 46848, 30464, 10240, 59392,  6144,
+   55296,  9216, 58368,  5120, 54272, 11008, 60160,  6912, 56064,  9984, 59136,
+    5888, 55040, 43008, 26624, 38912, 22528, 41984, 25600, 37888, 21504, 43776,
+   27392, 39680, 23296, 42752, 26368, 38656, 22272,   512, 49664, 12800, 61952,
+    3584, 52736, 15872, 65024,   256, 49408, 12544, 61696,  3328, 52480, 15616,
+   64768, 33280, 16896, 45568, 29184, 36352, 19968, 48640, 32256, 33024, 16640,
+   45312, 28928, 36096, 19712, 48384, 32000,  8704, 57856,  4608, 53760, 11776,
+   60928,  7680, 56832,  8448, 57600,  4352, 53504, 11520, 60672,  7424, 56576,
+   41472, 25088, 37376, 20992, 44544, 28160, 40448, 24064, 41216, 24832, 37120,
+   20736, 44288, 27904, 40192, 23808,  2560, 51712, 14848, 64000,  1536, 50688,
+   13824, 62976,  2304, 51456, 14592, 63744,  1280, 50432, 13568, 62720, 35328,
+   18944, 47616, 31232, 34304, 17920, 46592, 30208, 35072, 18688, 47360, 30976,
+   34048, 17664, 46336, 29952, 10752, 59904,  6656, 55808,  9728, 58880,  5632,
+   54784, 10496, 59648,  6400, 55552,  9472, 58624,  5376, 54528, 43520, 27136,
+   39424, 23040, 42496, 26112, 38400, 22016, 43264, 26880, 39168, 22784, 42240,
+   25856, 38144, 21760
+};
+
+const extern sal_uLong nVCLLut[ 256 ] =
+{
+         0,  1286,  2572,  3858,  5144,  6430,  7716,  9002,
+     10288, 11574, 12860, 14146, 15432, 16718, 18004, 19290,
+     20576, 21862, 23148, 24434, 25720, 27006, 28292, 29578,
+     30864, 32150, 33436, 34722, 36008, 37294, 38580, 39866,
+     41152, 42438, 43724, 45010, 46296, 47582, 48868, 50154,
+     51440, 52726, 54012, 55298, 56584, 57870, 59156, 60442,
+     61728, 63014, 64300, 65586, 66872, 68158, 69444, 70730,
+     72016, 73302, 74588, 75874, 77160, 78446, 79732, 81018,
+     82304, 83590, 84876, 86162, 87448, 88734, 90020, 91306,
+     92592, 93878, 95164, 96450, 97736, 99022,100308,101594,
+    102880,104166,105452,106738,108024,109310,110596,111882,
+    113168,114454,115740,117026,118312,119598,120884,122170,
+    123456,124742,126028,127314,128600,129886,131172,132458,
+    133744,135030,136316,137602,138888,140174,141460,142746,
+    144032,145318,146604,147890,149176,150462,151748,153034,
+    154320,155606,156892,158178,159464,160750,162036,163322,
+    164608,165894,167180,168466,169752,171038,172324,173610,
+    174896,176182,177468,178754,180040,181326,182612,183898,
+    185184,186470,187756,189042,190328,191614,192900,194186,
+    195472,196758,198044,199330,200616,201902,203188,204474,
+    205760,207046,208332,209618,210904,212190,213476,214762,
+    216048,217334,218620,219906,221192,222478,223764,225050,
+    226336,227622,228908,230194,231480,232766,234052,235338,
+    236624,237910,239196,240482,241768,243054,244340,245626,
+    246912,248198,249484,250770,252056,253342,254628,255914,
+    257200,258486,259772,261058,262344,263630,264916,266202,
+    267488,268774,270060,271346,272632,273918,275204,276490,
+    277776,279062,280348,281634,282920,284206,285492,286778,
+    288064,289350,290636,291922,293208,294494,295780,297066,
+    298352,299638,300924,302210,303496,304782,306068,307354,
+    308640,309926,311212,312498,313784,315070,316356,317642,
+    318928,320214,321500,322786,324072,325358,326644,327930
+};
+
+const int FloydMap[256] =
+{
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
+};
+
+constexpr int FloydErrMap[256]
+    = { 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+        52, 53, 54, 55, 5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+        23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
+        45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
+        16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
+        38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 5,  6,  7,  8,
+        9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+        31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
+        53, 54, 55, 5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+        24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
+        46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
+        17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 };
+
+constexpr int FloydError1[61] =
+{
+    -7680, -7424, -7168, -6912, -6656, -6400, -6144,
+    -5888, -5632, -5376, -5120, -4864, -4608, -4352,
+    -4096, -3840, -3584, -3328, -3072, -2816, -2560,
+    -2304, -2048, -1792, -1536, -1280, -1024, -768,
+    -512, -256, 0, 256, 512, 768, 1024, 1280, 1536,
+    1792, 2048, 2304, 2560, 2816, 3072, 3328, 3584,
+    3840, 4096, 4352, 4608, 4864, 5120, 5376, 5632,
+    5888, 6144, 6400, 6656, 6912, 7168, 7424, 7680
+};
+
+constexpr int FloydError3[61] =
+{
+    -23040, -22272, -21504, -20736, -19968, -19200,
+    -18432, -17664, -16896, -16128, -15360, -14592,
+    -13824, -13056, -12288, -11520, -10752, -9984,
+    -9216, -8448, -7680, -6912, -6144, -5376, -4608,
+    -3840, -3072, -2304, -1536, -768, 0, 768, 1536,
+    2304, 3072, 3840, 4608, 5376, 6144, 6912, 7680,
+    8448, 9216, 9984, 10752, 11520, 12288, 13056,
+    13824, 14592, 15360, 16128, 16896, 17664, 18432,
+    19200, 19968, 20736, 21504, 22272, 23040
+};
+
+constexpr int FloydError5[61] =
+{
+    -38400, -37120, -35840, -34560, -33280, -32000,
+    -30720, -29440, -28160, -26880, -25600, -24320,
+    -23040, -21760, -20480, -19200, -17920, -16640,
+    -15360, -14080, -12800, -11520, -10240, -8960,
+    -7680, -6400, -5120, -3840, -2560, -1280,   0,
+    1280, 2560, 3840, 5120, 6400, 7680, 8960, 10240,
+    11520, 12800, 14080, 15360, 16640, 17920, 19200,
+    20480, 21760, 23040, 24320, 25600, 26880, 28160,
+    29440, 30720, 32000, 33280, 34560, 35840, 37120,
+    38400
+};
+
+constexpr int FloydError7[61] =
+{
+    -53760, -51968, -50176, -48384, -46592, -44800,
+    -43008, -41216, -39424, -37632, -35840, -34048,
+    -32256, -30464, -28672, -26880, -25088, -23296,
+    -21504, -19712, -17920, -16128, -14336, -12544,
+    -10752, -8960, -7168, -5376, -3584, -1792,  0,
+    1792, 3584, 5376, 7168, 8960, 10752, 12544, 14336,
+    16128, 17920, 19712, 21504, 23296, 25088, 26880,
+    28672, 30464, 32256, 34048, 35840, 37632, 39424,
+    41216, 43008, 44800, 46592, 48384, 50176, 51968,
+    53760
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/vcl/source/bitmap/impvect.cxx b/vcl/source/bitmap/impvect.cxx
new file mode 100644
index 0000000000..3f8f8471a6
--- /dev/null
+++ b/vcl/source/bitmap/impvect.cxx
@@ -0,0 +1,996 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/log.hxx>
+#include <vcl/BitmapReadAccess.hxx>
+#include <tools/link.hxx>
+#include <tools/poly.hxx>
+#include <tools/helpers.hxx>
+#include <vcl/gdimtf.hxx>
+#include <vcl/metaact.hxx>
+#include <vcl/virdev.hxx>
+#include "impvect.hxx"
+#include <array>
+#include <memory>
+
+#define VECT_POLY_MAX 8192
+
+#define VECT_FREE_INDEX 0
+#define VECT_CONT_INDEX 1
+#define VECT_DONE_INDEX 2
+
+#define VECT_POLY_INLINE_INNER  1UL
+#define VECT_POLY_INLINE_OUTER  2UL
+#define VECT_POLY_OUTLINE_INNER 4UL
+#define VECT_POLY_OUTLINE_OUTER 8UL
+
+static void VECT_MAP( const std::unique_ptr<sal_Int32 []> & pMapIn, const std::unique_ptr<sal_Int32 []>& pMapOut, tools::Long nVal )
+{
+    pMapIn[nVal] = (nVal * 4) + 1;
+    pMapOut[nVal] = pMapIn[nVal] + 5;
+}
+static constexpr tools::Long BACK_MAP( tools::Long _def_nVal )
+{
+    return ((_def_nVal + 2) >> 2) - 1;
+}
+static void VECT_PROGRESS( const Link<tools::Long, void>* pProgress, tools::Long _def_nVal )
+{
+    if(pProgress)
+      pProgress->Call(_def_nVal);
+}
+
+namespace {
+
+class ImplVectMap;
+class ImplChain;
+
+}
+
+namespace ImplVectorizer
+{
+    static void ImplExpand( std::optional<ImplVectMap>& rMap, const BitmapReadAccess* pRAcc, const Color& rColor );
+    static void ImplCalculate( ImplVectMap& rMap, tools::PolyPolygon& rPolyPoly, sal_uInt8 cReduce );
+    static bool ImplGetChain( ImplVectMap& rMap, const Point& rStartPt, ImplChain& rChain );
+    static bool ImplIsUp( ImplVectMap const & rMap, tools::Long nY, tools::Long nX );
+    static void ImplLimitPolyPoly( tools::PolyPolygon& rPolyPoly );
+}
+
+namespace {
+
+struct ChainMove { tools::Long nDX; tools::Long nDY; };
+
+}
+
+const ChainMove aImplMove[ 8 ] =   {
+                                        { 1, 0 },
+                                        { 0, -1 },
+                                        { -1, 0 },
+                                        { 0, 1 },
+                                        { 1, -1 },
+                                        { -1, -1 },
+                                        { -1, 1 },
+                                        { 1, 1 }
+                                    };
+
+const ChainMove aImplMoveInner[ 8 ] =  {
+                                            { 0, 1 },
+                                            { 1, 0 },
+                                            { 0, -1 },
+                                            { -1, 0 },
+                                            { 0, 1 },
+                                            { 1, 0 },
+                                            { 0, -1 },
+                                            { -1, 0 }
+                                        };
+
+const ChainMove aImplMoveOuter[ 8 ] =  {
+                                            { 0, -1 },
+                                            { -1, 0 },
+                                            { 0, 1 },
+                                            { 1, 0 },
+                                            { -1, 0 },
+                                            { 0, 1 },
+                                            { 1, 0 },
+                                            { 0, -1 }
+                                        };
+
+namespace {
+
+struct ImplColorSet
+{
+    BitmapColor maColor;
+    sal_uInt16      mnIndex = 0;
+    bool        mbSet = false;
+};
+
+}
+
+static bool ImplColorSetCmpFnc( const ImplColorSet& lhs, const ImplColorSet& rhs)
+{
+    if( lhs.mbSet && rhs.mbSet )
+    {
+        const sal_uInt8 cLum1 = lhs.maColor.GetLuminance();
+        const sal_uInt8 cLum2 = rhs.maColor.GetLuminance();
+        return cLum1 < cLum2;
+    }
+    return lhs.mbSet > rhs.mbSet;
+}
+
+namespace {
+
+class ImplPointArray
+{
+    std::unique_ptr<Point[]> mpArray;
+    sal_uLong mnSize;
+    sal_uLong mnRealSize;
+
+public:
+
+    ImplPointArray();
+
+    void ImplSetSize( sal_uLong nSize );
+    sal_uLong ImplGetRealSize() const { return mnRealSize; }
+    void ImplSetRealSize( sal_uLong nRealSize ) { mnRealSize = nRealSize; }
+    void ImplCreatePoly( tools::Polygon& rPoly ) const;
+
+    inline Point& operator[]( sal_uLong nPos );
+    inline const Point& operator[]( sal_uLong nPos ) const;
+
+};
+
+}
+
+ImplPointArray::ImplPointArray() :
+    mnSize      ( 0 ),
+    mnRealSize  ( 0 )
+
+{
+}
+
+void ImplPointArray::ImplSetSize( sal_uLong nSize )
+{
+    const sal_uLong nTotal = nSize * sizeof( Point );
+
+    mnSize = nSize;
+    mnRealSize = 0;
+
+    mpArray = std::make_unique<Point[]>( nTotal );
+}
+
+inline Point& ImplPointArray::operator[]( sal_uLong nPos )
+{
+    SAL_WARN_IF( nPos >= mnSize, "vcl", "ImplPointArray::operator[]: nPos out of range!" );
+    return mpArray[ nPos ];
+}
+
+inline const Point& ImplPointArray::operator[]( sal_uLong nPos ) const
+{
+    SAL_WARN_IF( nPos >= mnSize, "vcl", "ImplPointArray::operator[]: nPos out of range!" );
+    return mpArray[ nPos ];
+}
+
+void ImplPointArray::ImplCreatePoly( tools::Polygon& rPoly ) const
+{
+    rPoly = tools::Polygon( sal::static_int_cast<sal_uInt16>(mnRealSize), mpArray.get() );
+}
+
+namespace {
+
+class ImplVectMap
+{
+private:
+
+    Scanline        mpBuf;
+    Scanline*       mpScan;
+    tools::Long            mnWidth;
+    tools::Long            mnHeight;
+
+public:
+
+                    ImplVectMap( tools::Long nWidth, tools::Long nHeight );
+                    ~ImplVectMap();
+
+    tools::Long     Width() const { return mnWidth; }
+    tools::Long     Height() const { return mnHeight; }
+
+    inline void     Set( tools::Long nY, tools::Long nX, sal_uInt8 cVal );
+    inline sal_uInt8        Get( tools::Long nY, tools::Long nX ) const;
+
+    inline bool     IsFree( tools::Long nY, tools::Long nX ) const;
+    inline bool     IsCont( tools::Long nY, tools::Long nX ) const;
+    inline bool     IsDone( tools::Long nY, tools::Long nX ) const;
+
+};
+
+}
+
+ImplVectMap::ImplVectMap( tools::Long nWidth, tools::Long nHeight ) :
+    mpBuf ( static_cast<Scanline>(rtl_allocateZeroMemory(nWidth * nHeight)) ),
+    mpScan ( static_cast<Scanline*>(std::malloc(nHeight * sizeof(Scanline))) ),
+    mnWidth ( nWidth ),
+    mnHeight( nHeight )
+{
+    const tools::Long  nWidthAl = ( nWidth >> 2 ) + 1;
+    Scanline    pTmp = mpBuf;
+
+    for( tools::Long nY = 0; nY < nHeight; pTmp += nWidthAl )
+        mpScan[ nY++ ] = pTmp;
+}
+
+ImplVectMap::~ImplVectMap()
+{
+    std::free( mpBuf );
+    std::free( mpScan );
+}
+
+inline void ImplVectMap::Set( tools::Long nY, tools::Long nX, sal_uInt8 cVal )
+{
+    const sal_uInt8 cShift = sal::static_int_cast<sal_uInt8>(6 - ( ( nX & 3 ) << 1 ));
+    auto & rPixel = mpScan[ nY ][ nX >> 2 ];
+    rPixel = (rPixel & ~( 3 << cShift ) ) | ( cVal << cShift );
+}
+
+inline sal_uInt8    ImplVectMap::Get( tools::Long nY, tools::Long nX ) const
+{
+    return sal::static_int_cast<sal_uInt8>( ( ( mpScan[ nY ][ nX >> 2 ] ) >> ( 6 - ( ( nX & 3 ) << 1 ) ) ) & 3 );
+}
+
+inline bool ImplVectMap::IsFree( tools::Long nY, tools::Long nX ) const
+{
+    return( VECT_FREE_INDEX == Get( nY, nX ) );
+}
+
+inline bool ImplVectMap::IsCont( tools::Long nY, tools::Long nX ) const
+{
+    return( VECT_CONT_INDEX == Get( nY, nX ) );
+}
+
+inline bool ImplVectMap::IsDone( tools::Long nY, tools::Long nX ) const
+{
+    return( VECT_DONE_INDEX == Get( nY, nX ) );
+}
+
+namespace {
+
+class ImplChain
+{
+private:
+
+    tools::Polygon  maPoly;
+    Point           maStartPt;
+    sal_uLong       mnArraySize;
+    sal_uLong       mnCount;
+    std::unique_ptr<sal_uInt8[]>
+                    mpCodes;
+
+    void            ImplGetSpace();
+
+    void            ImplPostProcess( const ImplPointArray& rArr );
+
+    ImplChain(const ImplChain&) = delete;
+    ImplChain& operator=(const ImplChain&) = delete;
+
+public:
+
+                    ImplChain();
+
+    void            ImplBeginAdd( const Point& rStartPt );
+    inline void     ImplAdd( sal_uInt8 nCode );
+    void            ImplEndAdd( sal_uLong nTypeFlag );
+
+    const tools::Polygon& ImplGetPoly() const { return maPoly; }
+};
+
+}
+
+ImplChain::ImplChain() :
+    mnArraySize ( 1024 ),
+    mnCount     ( 0 ),
+    mpCodes     ( new sal_uInt8[mnArraySize] )
+{
+}
+
+void ImplChain::ImplGetSpace()
+{
+    const sal_uLong nOldArraySize = mnArraySize;
+    sal_uInt8*      pNewCodes;
+
+    mnArraySize = mnArraySize << 1;
+    pNewCodes = new sal_uInt8[ mnArraySize ];
+    memcpy( pNewCodes, mpCodes.get(), nOldArraySize );
+    mpCodes.reset( pNewCodes );
+}
+
+void ImplChain::ImplBeginAdd( const Point& rStartPt )
+{
+    maPoly = tools::Polygon();
+    maStartPt = rStartPt;
+    mnCount = 0;
+}
+
+inline void ImplChain::ImplAdd( sal_uInt8 nCode )
+{
+    if( mnCount == mnArraySize )
+        ImplGetSpace();
+
+    mpCodes[ mnCount++ ] = nCode;
+}
+
+void ImplChain::ImplEndAdd( sal_uLong nFlag )
+{
+    if( mnCount )
+    {
+        ImplPointArray aArr;
+
+        if( nFlag & VECT_POLY_INLINE_INNER )
+        {
+            tools::Long nFirstX, nFirstY;
+            tools::Long nLastX, nLastY;
+
+            nFirstX = nLastX = maStartPt.X();
+            nFirstY = nLastY = maStartPt.Y();
+            aArr.ImplSetSize( mnCount << 1 );
+
+            sal_uInt16 nPolyPos;
+            sal_uLong i;
+            for( i = 0, nPolyPos = 0; i < ( mnCount - 1 ); i++ )
+            {
+                const sal_uInt8             cMove = mpCodes[ i ];
+                const sal_uInt8             cNextMove = mpCodes[ i + 1 ];
+                const ChainMove&        rMove = aImplMove[ cMove ];
+                const ChainMove&        rMoveInner = aImplMoveInner[ cMove ];
+//              Point&                  rPt = aArr[ nPolyPos ];
+                bool                    bDone = true;
+
+                nLastX += rMove.nDX;
+                nLastY += rMove.nDY;
+
+                if( cMove < 4 )
+                {
+                    if( ( cMove == 0 && cNextMove == 3 ) ||
+                        ( cMove == 3 && cNextMove == 2 ) ||
+                        ( cMove == 2 && cNextMove == 1 ) ||
+                        ( cMove == 1 && cNextMove == 0 ) )
+                    {
+                    }
+                    else if( cMove == 2 && cNextMove == 3 )
+                    {
+                        aArr[ nPolyPos ].setX( nLastX );
+                        aArr[ nPolyPos++ ].setY( nLastY - 1 );
+
+                        aArr[ nPolyPos ].setX( nLastX - 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY - 1 );
+
+                        aArr[ nPolyPos ].setX( nLastX - 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY );
+                    }
+                    else if( cMove == 3 && cNextMove == 0 )
+                    {
+                        aArr[ nPolyPos ].setX( nLastX - 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY );
+
+                        aArr[ nPolyPos ].setX( nLastX - 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY + 1 );
+
+                        aArr[ nPolyPos ].setX( nLastX );
+                        aArr[ nPolyPos++ ].setY( nLastY + 1 );
+                    }
+                    else if( cMove == 0 && cNextMove == 1 )
+                    {
+                        aArr[ nPolyPos ].setX( nLastX );
+                        aArr[ nPolyPos++ ].setY( nLastY + 1 );
+
+                        aArr[ nPolyPos ].setX( nLastX + 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY + 1 );
+
+                        aArr[ nPolyPos ].setX( nLastX + 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY );
+                    }
+                    else if( cMove == 1 && cNextMove == 2 )
+                    {
+                        aArr[ nPolyPos ].setX( nLastX + 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY + 1 );
+
+                        aArr[ nPolyPos ].setX( nLastX + 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY - 1 );
+
+                        aArr[ nPolyPos ].setX( nLastX );
+                        aArr[ nPolyPos++ ].setY( nLastY - 1 );
+                    }
+                    else
+                        bDone = false;
+                }
+                else if( cMove == 7 && cNextMove == 0 )
+                {
+                    aArr[ nPolyPos ].setX( nLastX - 1 );
+                    aArr[ nPolyPos++ ].setY( nLastY );
+
+                    aArr[ nPolyPos ].setX( nLastX );
+                    aArr[ nPolyPos++ ].setY( nLastY + 1 );
+                }
+                else if( cMove == 4 && cNextMove == 1 )
+                {
+                    aArr[ nPolyPos ].setX( nLastX );
+                    aArr[ nPolyPos++ ].setY( nLastY + 1 );
+
+                    aArr[ nPolyPos ].setX( nLastX + 1 );
+                    aArr[ nPolyPos++ ].setY( nLastY );
+                }
+                else
+                    bDone = false;
+
+                if( !bDone )
+                {
+                    aArr[ nPolyPos ].setX( nLastX + rMoveInner.nDX );
+                    aArr[ nPolyPos++ ].setY( nLastY + rMoveInner.nDY );
+                }
+            }
+
+            aArr[ nPolyPos ].setX( nFirstX + 1 );
+            aArr[ nPolyPos++ ].setY( nFirstY + 1 );
+            aArr.ImplSetRealSize( nPolyPos );
+        }
+        else if( nFlag & VECT_POLY_INLINE_OUTER )
+        {
+            tools::Long nFirstX, nFirstY;
+            tools::Long nLastX, nLastY;
+
+            nFirstX = nLastX = maStartPt.X();
+            nFirstY = nLastY = maStartPt.Y();
+            aArr.ImplSetSize( mnCount << 1 );
+
+            sal_uInt16 nPolyPos;
+            sal_uLong i;
+            for( i = 0, nPolyPos = 0; i < ( mnCount - 1 ); i++ )
+            {
+                const sal_uInt8             cMove = mpCodes[ i ];
+                const sal_uInt8             cNextMove = mpCodes[ i + 1 ];
+                const ChainMove&        rMove = aImplMove[ cMove ];
+                const ChainMove&        rMoveOuter = aImplMoveOuter[ cMove ];
+//              Point&                  rPt = aArr[ nPolyPos ];
+                bool                    bDone = true;
+
+                nLastX += rMove.nDX;
+                nLastY += rMove.nDY;
+
+                if( cMove < 4 )
+                {
+                    if( ( cMove == 0 && cNextMove == 1 ) ||
+                        ( cMove == 1 && cNextMove == 2 ) ||
+                        ( cMove == 2 && cNextMove == 3 ) ||
+                        ( cMove == 3 && cNextMove == 0 ) )
+                    {
+                    }
+                    else if( cMove == 0 && cNextMove == 3 )
+                    {
+                        aArr[ nPolyPos ].setX( nLastX );
+                        aArr[ nPolyPos++ ].setY( nLastY - 1 );
+
+                        aArr[ nPolyPos ].setX( nLastX + 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY - 1 );
+
+                        aArr[ nPolyPos ].setX( nLastX + 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY );
+                    }
+                    else if( cMove == 3 && cNextMove == 2 )
+                    {
+                        aArr[ nPolyPos ].setX( nLastX + 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY );
+
+                        aArr[ nPolyPos ].setX( nLastX + 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY + 1 );
+
+                        aArr[ nPolyPos ].setX( nLastX );
+                        aArr[ nPolyPos++ ].setY( nLastY + 1 );
+                    }
+                    else if( cMove == 2 && cNextMove == 1 )
+                    {
+                        aArr[ nPolyPos ].setX( nLastX );
+                        aArr[ nPolyPos++ ].setY( nLastY + 1 );
+
+                        aArr[ nPolyPos ].setX( nLastX - 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY + 1 );
+
+                        aArr[ nPolyPos ].setX( nLastX - 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY );
+                    }
+                    else if( cMove == 1 && cNextMove == 0 )
+                    {
+                        aArr[ nPolyPos ].setX( nLastX - 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY );
+
+                        aArr[ nPolyPos ].setX( nLastX - 1 );
+                        aArr[ nPolyPos++ ].setY( nLastY - 1 );
+
+                        aArr[ nPolyPos ].setX( nLastX );
+                        aArr[ nPolyPos++ ].setY( nLastY - 1 );
+                    }
+                    else
+                        bDone = false;
+                }
+                else if( cMove == 7 && cNextMove == 3 )
+                {
+                    aArr[ nPolyPos ].setX( nLastX );
+                    aArr[ nPolyPos++ ].setY( nLastY - 1 );
+
+                    aArr[ nPolyPos ].setX( nLastX + 1 );
+                    aArr[ nPolyPos++ ].setY( nLastY );
+                }
+                else if( cMove == 6 && cNextMove == 2 )
+                {
+                    aArr[ nPolyPos ].setX( nLastX + 1 );
+                    aArr[ nPolyPos++ ].setY( nLastY );
+
+                    aArr[ nPolyPos ].setX( nLastX );
+                    aArr[ nPolyPos++ ].setY( nLastY + 1 );
+                }
+                else
+                    bDone = false;
+
+                if( !bDone )
+                {
+                    aArr[ nPolyPos ].setX( nLastX + rMoveOuter.nDX );
+                    aArr[ nPolyPos++ ].setY( nLastY + rMoveOuter.nDY );
+                }
+            }
+
+            aArr[ nPolyPos ].setX( nFirstX - 1 );
+            aArr[ nPolyPos++ ].setY( nFirstY - 1 );
+            aArr.ImplSetRealSize( nPolyPos );
+        }
+        else
+        {
+            tools::Long nLastX = maStartPt.X(), nLastY = maStartPt.Y();
+
+            aArr.ImplSetSize( mnCount + 1 );
+            aArr[ 0 ] = Point( nLastX, nLastY );
+
+            for( sal_uLong i = 0; i < mnCount; )
+            {
+                const ChainMove& rMove = aImplMove[ mpCodes[ i ] ];
+                nLastX += rMove.nDX;
+                nLastY += rMove.nDY;
+                aArr[ ++i ] = Point( nLastX, nLastY );
+            }
+
+            aArr.ImplSetRealSize( mnCount + 1 );
+        }
+
+        ImplPostProcess( aArr );
+    }
+    else
+        maPoly.SetSize( 0 );
+}
+
+void ImplChain::ImplPostProcess( const ImplPointArray& rArr )
+{
+    ImplPointArray  aNewArr1;
+    ImplPointArray  aNewArr2;
+    Point*          pLast;
+    Point*          pLeast;
+    sal_uLong           nNewPos;
+    sal_uLong           nCount = rArr.ImplGetRealSize();
+    sal_uLong           n;
+
+    // pass 1
+    aNewArr1.ImplSetSize( nCount );
+    pLast = &( aNewArr1[ 0 ] );
+    pLast->setX( BACK_MAP( rArr[ 0 ].X() ) );
+    pLast->setY( BACK_MAP( rArr[ 0 ].Y() ) );
+
+    for( n = nNewPos = 1; n < nCount; )
+    {
+        const Point& rPt = rArr[ n++ ];
+        const tools::Long   nX = BACK_MAP( rPt.X() );
+        const tools::Long   nY = BACK_MAP( rPt.Y() );
+
+        if( nX != pLast->X() || nY != pLast->Y() )
+        {
+            pLast = pLeast = &( aNewArr1[ nNewPos++ ] );
+            pLeast->setX( nX );
+            pLeast->setY( nY );
+        }
+    }
+
+    nCount = nNewPos;
+    aNewArr1.ImplSetRealSize( nCount );
+
+    // pass 2
+    aNewArr2.ImplSetSize( nCount );
+    pLast = &( aNewArr2[ 0 ] );
+    *pLast = aNewArr1[ 0 ];
+
+    for( n = nNewPos = 1; n < nCount; )
+    {
+        pLeast = &( aNewArr1[ n++ ] );
+
+        if( pLeast->X() == pLast->X() )
+        {
+            while( n < nCount && aNewArr1[ n ].X() == pLast->X() )
+                pLeast = &( aNewArr1[ n++ ] );
+        }
+        else if( pLeast->Y() == pLast->Y() )
+        {
+            while( n < nCount && aNewArr1[ n ].Y() == pLast->Y() )
+                pLeast = &( aNewArr1[ n++ ] );
+        }
+
+        pLast = pLeast;
+        aNewArr2[ nNewPos++ ] = *pLast;
+    }
+
+    aNewArr2.ImplSetRealSize( nNewPos );
+    aNewArr2.ImplCreatePoly( maPoly );
+}
+
+namespace ImplVectorizer {
+
+bool ImplVectorize( const Bitmap& rColorBmp, GDIMetaFile& rMtf,
+                    sal_uInt8 cReduce, const Link<tools::Long,void>* pProgress )
+{
+    bool bRet = false;
+
+    VECT_PROGRESS( pProgress, 0 );
+
+    std::optional<Bitmap> xBmp(std::in_place, rColorBmp );
+    BitmapScopedReadAccess pRAcc(*xBmp);
+
+    if( pRAcc )
+    {
+        double              fPercent = 0.0;
+        double              fPercentStep_2 = 0.0;
+        const tools::Long          nWidth = pRAcc->Width();
+        const tools::Long          nHeight = pRAcc->Height();
+        const sal_uInt16        nColorCount = pRAcc->GetPaletteEntryCount();
+        sal_uInt16              n;
+        std::array<ImplColorSet, 256> aColorSet;
+
+        rMtf.Clear();
+
+        // get used palette colors and sort them from light to dark colors
+        for( n = 0; n < nColorCount; n++ )
+        {
+            aColorSet[ n ].mnIndex = n;
+            aColorSet[ n ].maColor = pRAcc->GetPaletteColor( n );
+        }
+
+        for( tools::Long nY = 0; nY < nHeight; nY++ )
+        {
+            Scanline pScanlineRead = pRAcc->GetScanline( nY );
+            for( tools::Long nX = 0; nX < nWidth; nX++ )
+                aColorSet[ pRAcc->GetIndexFromData( pScanlineRead, nX ) ].mbSet = true;
+        }
+
+        std::sort( aColorSet.begin(), aColorSet.end(), ImplColorSetCmpFnc );
+
+        for( n = 0; n < 256; n++ )
+            if( !aColorSet[ n ].mbSet )
+                break;
+
+        if( n )
+            fPercentStep_2 = 45.0 / n;
+
+        fPercent += 10.0;
+        VECT_PROGRESS( pProgress, FRound( fPercent ) );
+
+        for( sal_uInt16 i = 0; i < n; i++ )
+        {
+            const BitmapColor   aBmpCol( pRAcc->GetPaletteColor( aColorSet[ i ].mnIndex ) );
+            const Color         aFindColor( aBmpCol.GetRed(), aBmpCol.GetGreen(), aBmpCol.GetBlue() );
+            std::optional<ImplVectMap> oMap;
+            ImplExpand( oMap, pRAcc.get(), aFindColor );
+
+            fPercent += fPercentStep_2;
+            VECT_PROGRESS( pProgress, FRound( fPercent ) );
+
+            if( oMap )
+            {
+                tools::PolyPolygon         aPolyPoly;
+                ImplCalculate( *oMap, aPolyPoly, cReduce );
+                oMap.reset();
+
+                if( aPolyPoly.Count() )
+                {
+                    ImplLimitPolyPoly( aPolyPoly );
+
+                    aPolyPoly.Optimize( PolyOptimizeFlags::EDGES );
+
+                    if( aPolyPoly.Count() )
+                    {
+                        rMtf.AddAction( new MetaLineColorAction( aFindColor, true ) );
+                        rMtf.AddAction( new MetaFillColorAction( aFindColor, true ) );
+                        rMtf.AddAction( new MetaPolyPolygonAction( std::move(aPolyPoly) ) );
+                    }
+                }
+            }
+
+            fPercent += fPercentStep_2;
+            VECT_PROGRESS( pProgress, FRound( fPercent ) );
+        }
+
+        if( rMtf.GetActionSize() )
+        {
+            MapMode         aMap( MapUnit::Map100thMM );
+            ScopedVclPtrInstance< VirtualDevice > aVDev;
+            const Size      aLogSize1( aVDev->PixelToLogic( Size( 1, 1 ), aMap ) );
+
+            rMtf.SetPrefMapMode( aMap );
+            rMtf.SetPrefSize( Size( nWidth + 2, nHeight + 2 ) );
+            rMtf.Move( 1, 1 );
+            rMtf.Scale( aLogSize1.Width(), aLogSize1.Height() );
+            bRet = true;
+        }
+    }
+
+    pRAcc.reset();
+    xBmp.reset();
+    VECT_PROGRESS( pProgress, 100 );
+
+    return bRet;
+}
+
+void ImplLimitPolyPoly( tools::PolyPolygon& rPolyPoly )
+{
+    if( rPolyPoly.Count() <= VECT_POLY_MAX )
+        return;
+
+    tools::PolyPolygon aNewPolyPoly;
+    tools::Long        nReduce = 0;
+    sal_uInt16      nNewCount;
+
+    do
+    {
+        aNewPolyPoly.Clear();
+        nReduce++;
+
+        for( sal_uInt16 i = 0, nCount = rPolyPoly.Count(); i < nCount; i++ )
+        {
+            const tools::Rectangle aBound( rPolyPoly[ i ].GetBoundRect() );
+
+            if( aBound.GetWidth() > nReduce && aBound.GetHeight() > nReduce )
+            {
+                if( rPolyPoly[ i ].GetSize() )
+                    aNewPolyPoly.Insert( rPolyPoly[ i ] );
+            }
+        }
+
+        nNewCount = aNewPolyPoly.Count();
+    }
+    while( nNewCount > VECT_POLY_MAX );
+
+    rPolyPoly = aNewPolyPoly;
+}
+
+void ImplExpand( std::optional<ImplVectMap>& oMap, const BitmapReadAccess* pRAcc, const Color& rColor )
+{
+    if( !pRAcc || !pRAcc->Width() || !pRAcc->Height() )
+        return;
+
+    const tools::Long          nOldWidth = pRAcc->Width();
+    const tools::Long          nOldHeight = pRAcc->Height();
+    const tools::Long          nNewWidth = ( nOldWidth << 2 ) + 4;
+    const tools::Long          nNewHeight = ( nOldHeight << 2 ) + 4;
+    const BitmapColor   aTest( pRAcc->GetBestMatchingColor( rColor ) );
+    std::unique_ptr<sal_Int32[]> pMapIn(new sal_Int32[ std::max( nOldWidth, nOldHeight ) ]);
+    std::unique_ptr<sal_Int32[]> pMapOut(new sal_Int32[ std::max( nOldWidth, nOldHeight ) ]);
+    tools::Long                nX, nY, nTmpX, nTmpY;
+
+    oMap.emplace( nNewWidth, nNewHeight );
+
+    for( nX = 0; nX < nOldWidth; nX++ )
+        VECT_MAP( pMapIn, pMapOut, nX );
+
+    for( nY = 0, nTmpY = 5; nY < nOldHeight; nY++, nTmpY += 4 )
+    {
+        Scanline pScanlineRead = pRAcc->GetScanline( nY );
+        for( nX = 0; nX < nOldWidth; )
+        {
+            if( pRAcc->GetPixelFromData( pScanlineRead, nX ) == aTest )
+            {
+                nTmpX = pMapIn[ nX++ ];
+                nTmpY -= 3;
+
+                oMap->Set( nTmpY++, nTmpX, VECT_CONT_INDEX );
+                oMap->Set( nTmpY++, nTmpX, VECT_CONT_INDEX );
+                oMap->Set( nTmpY++, nTmpX, VECT_CONT_INDEX );
+                oMap->Set( nTmpY, nTmpX, VECT_CONT_INDEX );
+
+                while( nX < nOldWidth && pRAcc->GetPixelFromData( pScanlineRead, nX ) == aTest )
+                     nX++;
+
+                nTmpX = pMapOut[ nX - 1 ];
+                nTmpY -= 3;
+
+                oMap->Set( nTmpY++, nTmpX, VECT_CONT_INDEX );
+                oMap->Set( nTmpY++, nTmpX, VECT_CONT_INDEX );
+                oMap->Set( nTmpY++, nTmpX, VECT_CONT_INDEX );
+                oMap->Set( nTmpY, nTmpX, VECT_CONT_INDEX );
+            }
+            else
+                nX++;
+        }
+    }
+
+    for( nY = 0; nY < nOldHeight; nY++ )
+        VECT_MAP( pMapIn, pMapOut, nY );
+
+    for( nX = 0, nTmpX = 5; nX < nOldWidth; nX++, nTmpX += 4 )
+    {
+        for( nY = 0; nY < nOldHeight; )
+        {
+            if( pRAcc->GetPixel( nY, nX ) == aTest )
+            {
+                nTmpX -= 3;
+                nTmpY = pMapIn[ nY++ ];
+
+                oMap->Set( nTmpY, nTmpX++, VECT_CONT_INDEX );
+                oMap->Set( nTmpY, nTmpX++, VECT_CONT_INDEX );
+                oMap->Set( nTmpY, nTmpX++, VECT_CONT_INDEX );
+                oMap->Set( nTmpY, nTmpX, VECT_CONT_INDEX );
+
+                while( nY < nOldHeight && pRAcc->GetPixel( nY, nX ) == aTest )
+                    nY++;
+
+                nTmpX -= 3;
+                nTmpY = pMapOut[ nY - 1 ];
+
+                oMap->Set( nTmpY, nTmpX++, VECT_CONT_INDEX );
+                oMap->Set( nTmpY, nTmpX++, VECT_CONT_INDEX );
+                oMap->Set( nTmpY, nTmpX++, VECT_CONT_INDEX );
+                oMap->Set( nTmpY, nTmpX, VECT_CONT_INDEX );
+            }
+            else
+                nY++;
+        }
+    }
+}
+
+void ImplCalculate( ImplVectMap& rMap, tools::PolyPolygon& rPolyPoly, sal_uInt8 cReduce )
+{
+    const tools::Long nWidth = rMap.Width(), nHeight = rMap.Height();
+
+    for( tools::Long nY = 0; nY < nHeight; nY++ )
+    {
+        tools::Long    nX = 0;
+        bool    bInner = true;
+
+        while( nX < nWidth )
+        {
+            // skip free
+            while( ( nX < nWidth ) && rMap.IsFree( nY, nX ) )
+                nX++;
+
+            if( nX == nWidth )
+                break;
+
+            if( rMap.IsCont( nY, nX ) )
+            {
+                // new contour
+                ImplChain   aChain;
+                const Point aStartPt( nX++, nY );
+
+                // get chain code
+                aChain.ImplBeginAdd( aStartPt );
+                ImplGetChain( rMap, aStartPt, aChain );
+
+                aChain.ImplEndAdd( bInner ? VECT_POLY_OUTLINE_INNER : VECT_POLY_OUTLINE_OUTER );
+
+                const tools::Polygon& rPoly = aChain.ImplGetPoly();
+
+                if( rPoly.GetSize() > 2 )
+                {
+                    if( cReduce )
+                    {
+                        const tools::Rectangle aBound( rPoly.GetBoundRect() );
+
+                        if( aBound.GetWidth() > cReduce && aBound.GetHeight() > cReduce )
+                            rPolyPoly.Insert( rPoly );
+                    }
+                    else
+                        rPolyPoly.Insert( rPoly  );
+                }
+
+                // skip rest of detected contour
+                while( rMap.IsCont( nY, nX ) )
+                    nX++;
+            }
+            else
+            {
+                // process done segment
+                const tools::Long nStartSegX = nX++;
+
+                while( rMap.IsDone( nY, nX ) )
+                    nX++;
+
+                if( ( ( nX - nStartSegX ) == 1 ) || ( ImplIsUp( rMap, nY, nStartSegX ) != ImplIsUp( rMap, nY, nX - 1 ) ) )
+                    bInner = !bInner;
+            }
+        }
+    }
+}
+
+bool ImplGetChain(  ImplVectMap& rMap, const Point& rStartPt, ImplChain& rChain )
+{
+    tools::Long                nActX = rStartPt.X();
+    tools::Long                nActY = rStartPt.Y();
+    sal_uLong               nFound;
+    sal_uLong               nLastDir = 0;
+    sal_uLong               nDir;
+
+    do
+    {
+        nFound = 0;
+
+        // first try last direction
+        tools::Long nTryX = nActX + aImplMove[ nLastDir ].nDX;
+        tools::Long nTryY = nActY + aImplMove[ nLastDir ].nDY;
+
+        if( rMap.IsCont( nTryY, nTryX ) )
+        {
+            rChain.ImplAdd( static_cast<sal_uInt8>(nLastDir) );
+            nActY = nTryY;
+            nActX = nTryX;
+            rMap.Set( nActY, nActX, VECT_DONE_INDEX );
+            nFound = 1;
+        }
+        else
+        {
+            // try other directions
+            for( nDir = 0; nDir < 8; nDir++ )
+            {
+                // we already tried nLastDir
+                if( nDir != nLastDir )
+                {
+                    nTryX = nActX + aImplMove[ nDir ].nDX;
+                    nTryY = nActY + aImplMove[ nDir ].nDY;
+
+                    if( rMap.IsCont( nTryY, nTryX ) )
+                    {
+                        rChain.ImplAdd( static_cast<sal_uInt8>(nDir) );
+                        nActY = nTryY;
+                        nActX = nTryX;
+                        rMap.Set( nActY, nActX, VECT_DONE_INDEX );
+                        nFound = 1;
+                        nLastDir = nDir;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    while( nFound );
+
+    return true;
+}
+
+bool ImplIsUp( ImplVectMap const & rMap, tools::Long nY, tools::Long nX )
+{
+    if( rMap.IsDone( nY - 1, nX ) )
+        return true;
+    else if( rMap.IsDone( nY + 1, nX ) )
+        return false;
+    else if( rMap.IsDone( nY - 1, nX - 1 ) || rMap.IsDone( nY - 1, nX + 1 ) )
+        return true;
+    else
+        return false;
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/impvect.hxx b/vcl/source/bitmap/impvect.hxx
new file mode 100644
index 0000000000..257d1b5e5a
--- /dev/null
+++ b/vcl/source/bitmap/impvect.hxx
@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#pragma once
+
+#include <vcl/gdimtf.hxx>
+
+namespace tools { class PolyPolygon; }
+
+namespace ImplVectorizer
+{
+    bool     ImplVectorize( const Bitmap& rColorBmp, GDIMetaFile& rMtf,
+                            sal_uInt8 cReduce, const Link<tools::Long,void>* pProgress );
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/salbmp.cxx b/vcl/source/bitmap/salbmp.cxx
new file mode 100644
index 0000000000..67912262e6
--- /dev/null
+++ b/vcl/source/bitmap/salbmp.cxx
@@ -0,0 +1,335 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <salbmp.hxx>
+#include <o3tl/enumarray.hxx>
+#include <rtl/crc.h>
+
+static BitmapChecksum scanlineChecksum(BitmapChecksum nCrc, const sal_uInt8* bits, int lineBitsCount, sal_uInt8 extraBitsMask)
+{
+    if( lineBitsCount / 8 > 0 )
+        nCrc = rtl_crc32( nCrc, bits, lineBitsCount / 8 );
+    if( extraBitsMask != 0 )
+    {
+        sal_uInt8 extraByte = bits[ lineBitsCount / 8 ] & extraBitsMask;
+        nCrc = rtl_crc32( nCrc, &extraByte, 1 );
+    }
+    return nCrc;
+}
+
+void SalBitmap::updateChecksum() const
+{
+    if (mbChecksumValid)
+        return;
+
+    BitmapChecksum nCrc = 0;
+    SalBitmap* pThis = const_cast<SalBitmap*>(this);
+    BitmapBuffer* pBuf = pThis->AcquireBuffer(BitmapAccessMode::Read);
+    if (pBuf)
+    {
+        nCrc = pBuf->maPalette.GetChecksum();
+        const int lineBitsCount = pBuf->mnWidth * pBuf->mnBitCount;
+        // With 1bpp/4bpp format we need to check only used bits in the last byte.
+        sal_uInt8 extraBitsMask = 0;
+        if( lineBitsCount % 8 != 0 )
+        {
+            const int extraBitsCount = lineBitsCount % 8;
+            switch( RemoveScanline( pBuf->mnFormat ))
+            {
+                case ScanlineFormat::N1BitMsbPal:
+                {
+                    static const sal_uInt8 mask1Bit[] = { 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
+                    extraBitsMask = mask1Bit[ extraBitsCount ];
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        if( pBuf->mnFormat & ScanlineFormat::TopDown )
+        {
+            if( pBuf->mnScanlineSize == lineBitsCount / 8 )
+                nCrc = rtl_crc32(nCrc, pBuf->mpBits, pBuf->mnScanlineSize * pBuf->mnHeight);
+            else // Do not include padding with undefined content in the checksum.
+                for( tools::Long y = 0; y < pBuf->mnHeight; ++y )
+                    nCrc = scanlineChecksum(nCrc, pBuf->mpBits + y * pBuf->mnScanlineSize, lineBitsCount, extraBitsMask);
+        }
+        else // Compute checksum in the order of scanlines, to make it consistent between different bitmap implementations.
+        {
+            for( tools::Long y = pBuf->mnHeight - 1; y >= 0; --y )
+                nCrc = scanlineChecksum(nCrc, pBuf->mpBits + y * pBuf->mnScanlineSize, lineBitsCount, extraBitsMask);
+        }
+        pThis->ReleaseBuffer(pBuf, BitmapAccessMode::Read);
+        pThis->mnChecksum = nCrc;
+        pThis->mbChecksumValid = true;
+    }
+    else
+    {
+        pThis->mbChecksumValid = false;
+    }
+}
+
+namespace
+{
+
+class ImplPixelFormat
+{
+protected:
+    const sal_uInt8* mpData;
+public:
+    static ImplPixelFormat* GetFormat( sal_uInt16 nBits, const BitmapPalette& rPalette );
+
+    virtual void StartLine( const sal_uInt8* pLine ) { mpData = pLine; }
+    virtual const BitmapColor& ReadPixel() = 0;
+    virtual ~ImplPixelFormat() { }
+};
+
+class ImplPixelFormat8 : public ImplPixelFormat
+{
+private:
+    const BitmapPalette& mrPalette;
+
+public:
+    explicit ImplPixelFormat8( const BitmapPalette& rPalette )
+    : mrPalette( rPalette )
+    {
+    }
+    virtual const BitmapColor& ReadPixel() override
+    {
+        assert( mrPalette.GetEntryCount() > *mpData );
+        return mrPalette[ *mpData++ ];
+    }
+};
+
+class ImplPixelFormat4 : public ImplPixelFormat
+{
+private:
+    const BitmapPalette& mrPalette;
+    sal_uInt32 mnX;
+    sal_uInt32 mnShift;
+
+public:
+    explicit ImplPixelFormat4( const BitmapPalette& rPalette )
+        : mrPalette( rPalette )
+        , mnX(0)
+        , mnShift(4)
+    {
+    }
+    virtual void StartLine( const sal_uInt8* pLine ) override
+    {
+        mpData = pLine;
+        mnX = 0;
+        mnShift = 4;
+    }
+    virtual const BitmapColor& ReadPixel() override
+    {
+        sal_uInt32 nIdx = ( mpData[mnX >> 1] >> mnShift) & 0x0f;
+        assert( mrPalette.GetEntryCount() > nIdx );
+        const BitmapColor& rColor = mrPalette[nIdx];
+        mnX++;
+        mnShift ^= 4;
+        return rColor;
+    }
+};
+
+class ImplPixelFormat1 : public ImplPixelFormat
+{
+private:
+    const BitmapPalette& mrPalette;
+    sal_uInt32 mnX;
+
+public:
+    explicit ImplPixelFormat1( const BitmapPalette& rPalette )
+        : mrPalette(rPalette)
+        , mnX(0)
+    {
+    }
+    virtual void StartLine( const sal_uInt8* pLine ) override
+    {
+        mpData = pLine;
+        mnX = 0;
+    }
+    virtual const BitmapColor& ReadPixel() override
+    {
+        const BitmapColor& rColor = mrPalette[ (mpData[mnX >> 3 ] >> ( 7 - ( mnX & 7 ) )) & 1];
+        mnX++;
+        return rColor;
+    }
+};
+
+ImplPixelFormat* ImplPixelFormat::GetFormat( sal_uInt16 nBits, const BitmapPalette& rPalette )
+{
+    switch( nBits )
+    {
+    case 1: return new ImplPixelFormat1( rPalette );
+    case 4: return new ImplPixelFormat4( rPalette );
+    case 8: return new ImplPixelFormat8( rPalette );
+    }
+
+    return nullptr;
+}
+
+// Optimized conversion from 1bpp. Currently LO uses 1bpp bitmaps for masks, which is nowadays
+// a lousy obsolete format, as the memory saved is just not worth the cost of fiddling with the bits.
+// Ideally LO should move to RGBA bitmaps. Until then, try to be faster with 1bpp bitmaps.
+typedef void(*WriteColorFunction)( sal_uInt8 color8Bit, sal_uInt8*& dst );
+void writeColorA8(sal_uInt8 color8Bit, sal_uInt8*& dst ) { *dst++ = color8Bit; };
+void writeColorRGBA(sal_uInt8 color8Bit, sal_uInt8*& dst ) { *dst++ = color8Bit; *dst++ = color8Bit; *dst++ = color8Bit; *dst++ = 0xff; };
+typedef void(*WriteBlackWhiteFunction)( sal_uInt8*& dst, int count );
+void writeBlackA8(sal_uInt8*& dst, int count ) { memset( dst, 0, count ); dst += count; };
+void writeWhiteA8(sal_uInt8*& dst, int count ) { memset( dst, 0xff, count ); dst += count; };
+void writeWhiteRGBA(sal_uInt8*& dst, int count ) { memset( dst, 0xff, count * 4 ); dst += count * 4; };
+void writeBlackRGBA(sal_uInt8*& dst, int count )
+{
+    for( int i = 0; i < count; ++i )
+    {
+        dst[0] = 0x00;
+        dst[1] = 0x00;
+        dst[2] = 0x00;
+        dst[3] = 0xff;
+        dst += 4;
+    }
+};
+
+template< WriteColorFunction func, WriteBlackWhiteFunction funcBlack, WriteBlackWhiteFunction funcWhite >
+void writeBlackWhiteData( const sal_uInt8* src, sal_uInt8* dst, int width, int height, int bytesPerRow )
+{
+    for( int y = 0; y < height; ++y )
+    {
+        const sal_uInt8* srcLine = src;
+        int xsize = width;
+        while( xsize >= 64 )
+        {
+            // TODO alignment?
+            const sal_uInt64* src64 = reinterpret_cast< const sal_uInt64* >( src );
+            if( *src64 == 0x00 )
+                funcBlack( dst, 64 );
+            else if( *src64 == static_cast< sal_uInt64 >( -1 ))
+                funcWhite( dst, 64 );
+            else
+                break;
+            src += sizeof( sal_uInt64 );
+            xsize -= 64;
+        }
+        while( xsize >= 8 )
+        {
+            if( *src == 0x00 ) // => eight black pixels
+                funcBlack( dst, 8 );
+            else if( *src == 0xff ) // => eight white pixels
+                funcWhite( dst, 8 );
+            else
+                for( int bit = 7; bit >= 0; --bit )
+                    func(( *src >> bit ) & 1 ? 0xff : 0, dst );
+            ++src;
+            xsize -= 8;
+        }
+        for( int bit = 7; bit > 7 - xsize; --bit )
+            func(( *src >> bit ) & 1 ? 0xff : 0, dst );
+        ++src;
+        src = srcLine + bytesPerRow;
+    }
+}
+
+} // namespace
+
+std::unique_ptr< sal_uInt8[] > SalBitmap::convertDataBitCount( const sal_uInt8* src,
+    int width, int height, int bitCount, int bytesPerRow, const BitmapPalette& palette, BitConvert type )
+{
+    assert( bitCount == 1 || bitCount == 4 || bitCount == 8 );
+    static const o3tl::enumarray<BitConvert, int> bpp = { 1, 4, 4 };
+    std::unique_ptr< sal_uInt8[] > data( new sal_uInt8[width * height * bpp[ type ]] );
+
+    if(type == BitConvert::A8 && bitCount == 8 && palette.IsGreyPalette8Bit())
+    { // no actual data conversion
+        for( int y = 0; y < height; ++y )
+            memcpy( data.get() + y * width, src + y * bytesPerRow, width );
+        return data;
+    }
+
+    if(bitCount == 1 && palette.GetEntryCount() == 2 && palette[ 0 ] == COL_BLACK && palette[ 1 ] == COL_WHITE)
+    {
+        switch( type )
+        {
+            case BitConvert::A8 :
+                writeBlackWhiteData< writeColorA8, writeBlackA8, writeWhiteA8 >
+                    ( src, data.get(), width, height, bytesPerRow );
+                return data;
+            case BitConvert::BGRA :
+            case BitConvert::RGBA :
+                // BGRA/RGBA is the same, all 3 values get the same value
+                writeBlackWhiteData< writeColorRGBA, writeBlackRGBA, writeWhiteRGBA >
+                    ( src, data.get(), width, height, bytesPerRow );
+                return data;
+        }
+    }
+
+    std::unique_ptr<ImplPixelFormat> pSrcFormat(ImplPixelFormat::GetFormat(bitCount, palette));
+
+    const sal_uInt8* pSrcData = src;
+    sal_uInt8* pDstData = data.get();
+
+    sal_uInt32 nY = height;
+    while( nY-- )
+    {
+        pSrcFormat->StartLine( pSrcData );
+
+        sal_uInt32 nX = width;
+        switch( type )
+        {
+            case BitConvert::A8 :
+                while( nX-- )
+                {
+                    const BitmapColor& c = pSrcFormat->ReadPixel();
+                    *pDstData++ = c.GetBlue();
+                }
+                break;
+            case BitConvert::BGRA :
+                while( nX-- )
+                {
+                    const BitmapColor& c = pSrcFormat->ReadPixel();
+                    *pDstData++ = c.GetBlue();
+                    *pDstData++ = c.GetGreen();
+                    *pDstData++ = c.GetRed();
+                    *pDstData++ = 0xff;
+                }
+                break;
+            case BitConvert::RGBA :
+                while( nX-- )
+                {
+                    const BitmapColor& c = pSrcFormat->ReadPixel();
+                    *pDstData++ = c.GetRed();
+                    *pDstData++ = c.GetGreen();
+                    *pDstData++ = c.GetBlue();
+                    *pDstData++ = 0xff;
+                }
+                break;
+        }
+
+        pSrcData += bytesPerRow;
+    }
+    return data;
+}
+
+const basegfx::SystemDependentDataHolder* SalBitmap::accessSystemDependentDataHolder() const
+{
+    // default has no support, returns nullptr
+    return nullptr;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */