[Libreoffice-commits] core.git: Branch 'private/tvajngerl/staging' - 1088 commits - accessibility/inc accessibility/source animations/source avmedia/inc avmedia/source basctl/inc basctl/sdi basctl/source basctl/uiconfig basctl/UIConfig_basicide.mk basegfx/source basegfx/test basic/inc basic/qa basic/source binaryurp/source bin/find-can-be-private-symbols.classes.results bin/find-mergedlib-can-be-private.classes.results bin/find-unneeded-includes bin/gbuild-to-ide bin/get_config_variables bridges/inc bridges/Library_cpp_uno.mk bridges/source canvas/inc canvas/source chart2/inc chart2/Library_chartcore.mk chart2/qa chart2/source chart2/uiconfig chart2/workbench cli_ure/Module_cli_ure.mk codemaker/source comphelper/source compilerplugins/clang config_host/config_global.h.in config_host/config_qrcodegen.h.in config_host/config_skia.h.in config_host.mk.in configmgr/source configure.ac connectivity/inc connectivity/source cppcanvas/inc cppcanvas/source cppuhelper/inc cppuhelper/source cppu/source cui/i nc cui/Library_cui.mk cui/qa cui/source cui/uiconfig cui/UIConfig_cui.mk dbaccess/inc dbaccess/Library_dbu.mk dbaccess/source dbaccess/uiconfig dbaccess/UIConfig_dbaccess.mk desktop/inc desktop/IwyuFilter_desktop.yaml desktop/qa desktop/source desktop/unx desktop/win32 distro-configs/Jenkins distro-configs/LibreOfficeOssFuzz.conf distro-configs/LibreOfficeWin32.conf distro-configs/LibreOfficeWin64.conf download.lst drawinglayer/inc drawinglayer/source dtrans/source dtrans/test editeng/inc editeng/source embeddedobj/source embeddedobj/test embedserv/source emfio/CppunitTest_emfio_emf.mk emfio/CppunitTest_emfio_emf_test.mk emfio/CppunitTest_emfio_wmf.mk emfio/CppunitTest_emfio_wmf_test.mk emfio/inc emfio/Module_emfio.mk emfio/qa emfio/source extensions/Executable_twain32shim.mk extensions/IwyuFilter_extensions.yaml extensions/source external/apache-commons external/beanshell external/cppunit external/curl external/gpgmepp external/hsqldb external/icu external/jfreereport external/lang uagetool external/lcms2 external/libassuan external/libgpg-error external/libjpeg-turbo external/liblangtag external/liborcus external/mdds external/nss external/pdfium external/python3 external/qrcodegen external/redland external/rhino external/skia extras/source filter/qa filter/source forms/inc forms/source formula/source formula/uiconfig fpicker/source framework/inc framework/Library_fwk.mk framework/source framework/util .git-hooks/pre-commit .git-hooks/README helpcontent2 hwpfilter/source i18npool/source icon-themes/breeze icon-themes/breeze_dark icon-themes/breeze_dark_svg icon-themes/breeze_svg icon-themes/colibre icon-themes/colibre_svg icon-themes/elementary icon-themes/elementary_svg icon-themes/karasa_jaga icon-themes/karasa_jaga_svg icon-themes/sifr icon-themes/sifr_dark icon-themes/sifr_dark_svg icon-themes/sifr_svg icon-themes/sukapura icon-themes/sukapura_svg idlc/inc idlc/source idlc/test idl/inc idl/source include/avmedia include/basegfx include/codemaker include/c om include/comphelper include/cppuhelper include/dbaccess include/editeng include/LibreOfficeKit include/o3tl include/oox include/osl include/registry include/rtl include/sal include/sfx2 include/svl include/svtools include/svx include/test include/tools include/typelib include/uno include/unotools include/vcl include/xmloff ios/LibreOfficeLight javaunohelper/test jvmfwk/inc jvmfwk/plugins jvmfwk/source l10ntools/source libreofficekit/qa libreofficekit/source linguistic/source lotuswordpro/inc lotuswordpro/source Makefile.gbuild Makefile.in odk/examples offapi/com officecfg/registry oovbaapi/ooo oox/inc oox/qa oox/source opencl/source package/source postprocess/CustomTarget_images.mk postprocess/CustomTarget_registry.mk postprocess/Module_postprocess.mk postprocess/Rdb_services.mk pyuno/demo qadevOOo/tests readlicense_oo/docs readlicense_oo/license registry/source reportbuilder/java reportdesign/inc reportdesign/source reportdesign/uiconfig reportdesign/UIConfig_dbreport.mk Reposito ryExternal.mk Repository.mk RepositoryModule_build.mk ridljar/com sal/CompilerTest_sal_rtl_oustring.mk sal/cppunittester sal/CppunitTest_sal_rtl.mk sal/Library_sal.mk sal/Module_sal.mk sal/osl sal/qa sal/rtl sal/util sax/qa sax/source scaddins/source sc/CppunitTest_sc_jumbosheets_test.mk schema/libreoffice schema/mathml2 sc/inc sc/IwyuFilter_sc.yaml sc/Library_scui.mk sc/Module_sc.mk scp2/AutoInstall.mk scp2/inc scp2/source sc/qa scripting/java scripting/source sc/sdi sc/source sc/uiconfig sc/UITest_options.mk sc/UITest_sc_options.mk sd/CppunitTest_sd_tiledrendering.mk sdext/source sd/inc sd/qa sd/sdi sd/source sd/uiconfig sd/UIConfig_sdraw.mk sd/UIConfig_simpress.mk sd/xml sfx2/inc sfx2/Library_sfx.mk sfx2/qa sfx2/sdi sfx2/source sfx2/uiconfig sfx2/UIConfig_sfx.mk shell/Library_spsupp_x86.mk shell/Module_shell.mk shell/source slideshow/inc slideshow/README slideshow/source solenv/bin solenv/clang-format solenv/CompilerTest_compilerplugins_clang.mk solenv/flatpak-manifest.in solenv/ gbuild solenv/gcc-wrappers solenv/gdb solenv/sanitizers sot/inc starmath/inc starmath/Library_sm.mk starmath/qa starmath/sdi starmath/source stoc/source svgio/inc svgio/source svl/inc svl/qa svl/source svtools/inc svtools/Library_svt.mk svtools/source svtools/uiconfig svtools/UIConfig_svt.mk svx/inc svx/IwyuFilter_svx.yaml svx/Library_svxcore.mk svx/Library_svx.mk svx/Module_svx.mk svx/qa svx/sdi svx/source svx/uiconfig sw/CppunitTest_sw_core_draw.mk sw/CppunitTest_sw_core_layout.mk sw/CppunitTest_sw_uibase_uiview.mk sw/CppunitTest_sw_ww8export.mk sw/inc sw/Module_sw.mk sw/PythonTest_sw_python.mk sw/qa sw/sdi sw/source sw/uiconfig sw/UITest_options.mk sw/UITest_sw_options.mk sysui/desktop test/source testtools/source test/user-template toolkit/source tools/source translations ucb/source uitest/ui_logger_dsl unoil/Module_unoil.mk unotest/Module_unotest.mk unotools/inc unotools/source unoxml/Module_unoxml.mk uui/inc uui/source vbahelper/source vcl/backendtest vcl/Executable_benchmark. mk vcl/headless vcl/inc vcl/Library_vcl.mk vcl/Library_vclplug_win.mk vcl/Module_vcl.mk vcl/opengl vcl/osx vcl/qa vcl/qt5 vcl/quartz vcl/skia vcl/source vcl/unx vcl/win vcl/workben winaccessibility/inc winaccessibility/source wizards/com wizards/source writerfilter/inc writerfilter/qa writerfilter/source writerperfect/source xmlhelp/source xmloff/inc xmloff/Module_xmloff.mk xmloff/source xmloff/util xmlscript/source xmlsecurity/inc xmlsecurity/IwyuFilter_xmlsecurity.yaml xmlsecurity/Library_xmlsecurity.mk xmlsecurity/qa xmlsecurity/source xmlsecurity/uiconfig xmlsecurity/workben

[Tomaž Vajngerl (via logerrit)]

Rebased ref, commits from common ancestor:
commit 1c38d602ccab3ef62825662b1b36569c3c702964
Author:     Tomaž Vajngerl <tomaz.vajng...@collabora.co.uk>
AuthorDate: Tue May 22 14:44:39 2018 +0900
Commit:     Tomaž Vajngerl <tomaz.vajng...@collabora.co.uk>
CommitDate: Tue Sep 22 08:17:50 2020 +0200

    Command Popup
    
    Change-Id: I92cdd3130b8de42ee0863c9e7154e7c7246d9377

diff --git a/include/sfx2/sfxsids.hrc b/include/sfx2/sfxsids.hrc
index 88d708e4cb98..7cf9ccc52ce0 100644
--- a/include/sfx2/sfxsids.hrc
+++ b/include/sfx2/sfxsids.hrc
@@ -382,7 +382,7 @@ class SvxSearchItem;
 
 // default-ids for windows
 
-// free                                     (SID_SFX_START + 610)
+#define SID_COMMAND_POPUP                   (SID_SFX_START + 610)
 #define SID_NEWWINDOW                       (SID_SFX_START + 620)
 #define SID_CLOSEWIN                        (SID_SFX_START + 621)
 #define SID_VIEWSHELL                       (SID_SFX_START + 623)
diff --git a/officecfg/registry/data/org/openoffice/Office/Accelerators.xcu 
b/officecfg/registry/data/org/openoffice/Office/Accelerators.xcu
index b8a46cfc035a..2db3f82fc808 100644
--- a/officecfg/registry/data/org/openoffice/Office/Accelerators.xcu
+++ b/officecfg/registry/data/org/openoffice/Office/Accelerators.xcu
@@ -313,6 +313,12 @@ Ctrl+Shift+e aka E_SHIFT_MOD1 under GTK/IBUS is for some 
emoji thing
           <value xml:lang="en-US" 
install:module="unxwnt">.uno:OptionsTreeDialog</value>
         </prop>
       </node>
+      <node oor:name="SPACE_MOD1" oor:op="replace">
+        <prop oor:name="Command">
+          <value xml:lang="x-no-translate">I10N SHORTCUTS - NO 
TRANSLATE</value>
+          <value xml:lang="en-US">.uno:CommandPopup</value>
+        </prop>
+      </node>
     </node>
     <node oor:name="Modules">
       <node oor:name="com.sun.star.script.BasicIDE" oor:op="replace">
diff --git 
a/officecfg/registry/data/org/openoffice/Office/UI/GenericCommands.xcu 
b/officecfg/registry/data/org/openoffice/Office/UI/GenericCommands.xcu
index 97b8e210924c..4dde5dd0d73d 100644
--- a/officecfg/registry/data/org/openoffice/Office/UI/GenericCommands.xcu
+++ b/officecfg/registry/data/org/openoffice/Office/UI/GenericCommands.xcu
@@ -6488,6 +6488,14 @@
           <value>1</value>
         </prop>
       </node>
+      <node oor:name=".uno:CommandPopup" oor:op="replace">
+        <prop oor:name="Label" oor:type="xs:string">
+          <value xml:lang="en-US">Command Popup</value>
+        </prop>
+        <prop oor:name="Properties" oor:type="xs:int">
+          <value>1</value>
+        </prop>
+      </node>
     </node>
     <node oor:name="Popups">
       <node oor:name=".uno:PasteSpecialMenu" oor:op="replace">
diff --git a/sfx2/Library_sfx.mk b/sfx2/Library_sfx.mk
index cb0b099eb37d..4c7d994de08d 100644
--- a/sfx2/Library_sfx.mk
+++ b/sfx2/Library_sfx.mk
@@ -296,6 +296,7 @@ $(eval $(call gb_Library_add_exception_objects,sfx,\
     sfx2/source/styles/StyleManager \
     sfx2/source/toolbox/tbxitem \
     sfx2/source/toolbox/weldutils \
+    sfx2/source/view/CommandPopup \
     sfx2/source/view/classificationcontroller \
     sfx2/source/view/classificationhelper \
     sfx2/source/view/frame \
diff --git a/sfx2/UIConfig_sfx.mk b/sfx2/UIConfig_sfx.mk
index 5bb91d7ac6f6..da64557e8964 100644
--- a/sfx2/UIConfig_sfx.mk
+++ b/sfx2/UIConfig_sfx.mk
@@ -21,6 +21,7 @@ $(eval $(call gb_UIConfig_add_uifiles,sfx,\
        sfx2/uiconfig/ui/classificationbox \
        sfx2/uiconfig/ui/cmisinfopage \
        sfx2/uiconfig/ui/cmisline \
+       sfx2/uiconfig/ui/commandpopup \
        sfx2/uiconfig/ui/custominfopage \
        sfx2/uiconfig/ui/descriptioninfopage \
        sfx2/uiconfig/ui/dockingwindow \
diff --git a/sfx2/sdi/frmslots.sdi b/sfx2/sdi/frmslots.sdi
index 09aafef95b7d..a7c8a472e73d 100644
--- a/sfx2/sdi/frmslots.sdi
+++ b/sfx2/sdi/frmslots.sdi
@@ -262,6 +262,11 @@ interface TopWindow : BrowseWindow
         ExecMethod = MiscExec_Impl ;
         StateMethod = MiscState_Impl ;
     ]
+    SID_COMMAND_POPUP
+    [
+        ExecMethod = MiscExec_Impl ;
+        StateMethod = MiscState_Impl ;
+    ]
     SID_CLOSEWIN // ole(no) api(final/play/rec)
     [
         ExecMethod = Exec_Impl ;
@@ -307,4 +312,3 @@ shell SfxViewFrame
         StateMethod = GetState_Impl ;
     ]
 }
-
diff --git a/sfx2/sdi/sfx.sdi b/sfx2/sdi/sfx.sdi
index a50b5f1a17a6..813ef070c978 100644
--- a/sfx2/sdi/sfx.sdi
+++ b/sfx2/sdi/sfx.sdi
@@ -1271,6 +1271,23 @@ SfxStringItem FullName SID_DOCFULLNAME
     GroupId = ;
 ]
 
+SfxVoidItem CommandPopup SID_COMMAND_POPUP
+[
+    AutoUpdate = TRUE,
+    FastCall = FALSE,
+    ReadOnlyDoc = TRUE,
+    Toggle = FALSE,
+    Container = TRUE,
+    RecordAbsolute = FALSE,
+    RecordPerSet;
+    Asynchron;
+
+
+    AccelConfig = TRUE,
+    MenuConfig = TRUE,
+    ToolBoxConfig = TRUE,
+    GroupId = SfxGroupId::View;
+]
 
 SfxBoolItem FullScreen SID_WIN_FULLSCREEN
 
diff --git a/sfx2/source/view/CommandPopup.cxx 
b/sfx2/source/view/CommandPopup.cxx
new file mode 100644
index 000000000000..0bbe8adba5b2
--- /dev/null
+++ b/sfx2/source/view/CommandPopup.cxx
@@ -0,0 +1,220 @@
+/* -*- 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 "CommandPopup.hxx"
+
+#include <vcl/layout.hxx>
+#include <vcl/fixed.hxx>
+#include <workwin.hxx>
+#include <sfx2/msgpool.hxx>
+
+#include <comphelper/processfactory.hxx>
+#include <comphelper/dispatchcommand.hxx>
+
+#include <com/sun/star/frame/XDispatchInformationProvider.hpp>
+#include <com/sun/star/frame/theUICommandDescription.hpp>
+#include <com/sun/star/ui/theUICategoryDescription.hpp>
+
+#include <com/sun/star/ui/theModuleUIConfigurationManagerSupplier.hpp>
+#include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp>
+
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+
+#include <vcl/commandinfoprovider.hxx>
+
+using namespace css;
+
+CommandListBox::CommandListBox(vcl::Window* pParent, CommandPopup& rPopUp,
+                               uno::Reference<frame::XFrame> xFrame)
+    : InterimItemWindow(pParent, "sfx/ui/commandpopup.ui", "CommandBox")
+    , m_rPopUp(rPopUp)
+    , m_xFrame(xFrame)
+    , m_pEntry(m_xBuilder->weld_entry("entry"))
+    , m_pListBox(m_xBuilder->weld_tree_view("listBox"))
+{
+    m_pEntry->connect_changed(LINK(this, CommandListBox, ModifyHdl));
+}
+
+void CommandListBox::recurse(uno::Reference<container::XIndexAccess> 
xIndexAccess,
+                             MenuContent& rMenuContent)
+{
+    for (sal_Int32 n = 0; n < xIndexAccess->getCount(); n++)
+    {
+        MenuContent aNewContent;
+        OUString aModuleIdentifier;
+        uno::Sequence<beans::PropertyValue> aProperty;
+        uno::Reference<container::XIndexAccess> xIndexContainer;
+        try
+        {
+            if (xIndexAccess->getByIndex(n) >>= aProperty)
+            {
+                bool bShow = true;
+                bool bEnabled = true;
+
+                for (int i = 0; i < aProperty.getLength(); i++)
+                {
+                    OUString aPropName = aProperty[i].Name;
+                    if (aPropName == "CommandURL")
+                        aProperty[i].Value >>= aNewContent.m_aCommandURL;
+                    else if (aPropName == "ItemDescriptorContainer")
+                        aProperty[i].Value >>= xIndexContainer;
+                    else if (aPropName == "ModuleIdentifier")
+                        aProperty[i].Value >>= aModuleIdentifier;
+                    else if (aPropName == "IsVisible")
+                        aProperty[i].Value >>= bShow;
+                    else if (aPropName == "Enabled")
+                        aProperty[i].Value >>= bEnabled;
+                }
+
+                OUString 
aModuleName(vcl::CommandInfoProvider::GetModuleIdentifier(m_xFrame));
+                auto aProperties = 
vcl::CommandInfoProvider::GetCommandProperties(
+                    aNewContent.m_aCommandURL, aModuleName);
+                aNewContent.m_aMenuLabel
+                    = 
vcl::CommandInfoProvider::GetMenuLabelForCommand(aProperties)
+                          .replaceAll("~", "");
+                aNewContent.m_aLabel = rMenuContent.m_aLabel + " -> " + 
aNewContent.m_aMenuLabel;
+                //OUString 
aTooltip(vcl::CommandInfoProvider::GetTooltipForCommand(aNewContent.m_aCommandURL,
 aProperties, m_xFrame));
+                if (xIndexContainer.is())
+                    recurse(xIndexContainer, aNewContent);
+
+                rMenuContent.m_aSubMenuContent.push_back(aNewContent);
+            }
+        }
+        catch (const lang::IndexOutOfBoundsException&)
+        {
+            return;
+        }
+    }
+}
+
+void CommandListBox::initialize()
+{
+    m_xGlobalCategoryInfo
+        = 
ui::theUICategoryDescription::get(comphelper::getProcessComponentContext());
+    m_sModuleLongName = 
vcl::CommandInfoProvider::GetModuleIdentifier(m_xFrame);
+    
m_xModuleCategoryInfo.set(m_xGlobalCategoryInfo->getByName(m_sModuleLongName),
+                              uno::UNO_QUERY_THROW);
+    m_xUICmdDescription
+        = 
frame::theUICommandDescription::get(comphelper::getProcessComponentContext());
+
+    uno::Reference<ui::XModuleUIConfigurationManagerSupplier> 
xModuleCfgSupplier
+        = ui::theModuleUIConfigurationManagerSupplier::get(
+            comphelper::getProcessComponentContext());
+
+    uno::Reference<ui::XUIConfigurationManager> xCfgMgr
+        = xModuleCfgSupplier->getUIConfigurationManager(m_sModuleLongName);
+    uno::Reference<container::XIndexAccess> xConfigData
+        = xCfgMgr->getSettings("private:resource/menubar/menubar", false);
+
+    recurse(xConfigData, m_aMenuContent);
+
+    Size aSize(400, 400);
+    SetSizePixel(aSize);
+    m_rPopUp.SetOutputSizePixel(aSize);
+    m_rPopUp.StartPopupMode(tools::Rectangle(Point(10, 10), aSize),
+                            FloatWinPopupFlags::Down | 
FloatWinPopupFlags::GrabFocus
+                                | FloatWinPopupFlags::AllMouseButtonClose
+                                | FloatWinPopupFlags::NoMouseUpClose);
+
+    Show();
+
+    GrabFocus();
+    m_pEntry->grab_focus();
+}
+
+void CommandListBox::dispose()
+{
+    m_pEntry.reset();
+    m_pListBox.reset();
+    InterimItemWindow::dispose();
+}
+
+IMPL_LINK_NOARG(CommandListBox, ModifyHdl, weld::Entry&, void)
+{
+    m_pListBox->clear();
+
+    OUString sText = m_pEntry->get_text();
+    if (sText.isEmpty())
+        return;
+
+    m_aCommandList.clear();
+
+    m_pListBox->freeze();
+    findInMenu(m_aMenuContent, sText.toAsciiLowerCase());
+    m_pListBox->thaw();
+
+    if (m_pListBox->n_children() > 0)
+    {
+        m_pListBox->set_cursor(0);
+        m_pListBox->select(0);
+    }
+
+    m_pEntry->grab_focus();
+}
+
+void CommandListBox::findInMenu(MenuContent& aMenuContent, OUString const& 
rText)
+{
+    for (MenuContent& aSubContent : aMenuContent.m_aSubMenuContent)
+    {
+        if (aSubContent.m_aMenuLabel.toAsciiLowerCase().startsWith(rText))
+        {
+            OUString sCommandURL = aSubContent.m_aCommandURL;
+            //Image aImage = 
vcl::CommandInfoProvider::GetImageForCommand(sCommandURL, m_xFrame);
+            m_pListBox->append_text(aSubContent.m_aLabel);
+            m_aCommandList.push_back(sCommandURL);
+        }
+        findInMenu(aSubContent, rText);
+    }
+}
+
+bool CommandListBox::EventNotify(NotifyEvent& rNotifyEvent)
+{
+    const KeyEvent* pKeyEvent = rNotifyEvent.GetKeyEvent();
+
+    if (pKeyEvent)
+    {
+        if (pKeyEvent->GetKeyCode().GetCode() == KEY_DOWN
+            || pKeyEvent->GetKeyCode().GetCode() == KEY_UP)
+        {
+            m_pListBox->grab_focus();
+        }
+        else if (pKeyEvent->GetKeyCode().GetCode() == KEY_RETURN)
+        {
+            size_t nSelected = m_pListBox->get_selected_index();
+            if (nSelected < m_aCommandList.size())
+            {
+                OUString sCommand = m_aCommandList[nSelected];
+                dispatchCommandAndClose(sCommand);
+            }
+        }
+        else
+        {
+            m_pEntry->grab_focus();
+        }
+    }
+
+    return InterimItemWindow::EventNotify(rNotifyEvent);
+}
+
+void CommandListBox::dispatchCommandAndClose(OUString const& rCommand)
+{
+    m_rPopUp.EndPopupMode(FloatWinPopupEndFlags::CloseAll);
+    comphelper::dispatchCommand(rCommand, 
uno::Sequence<beans::PropertyValue>());
+}
+
+CommandPopup::CommandPopup(vcl::Window* pParent)
+    : FloatingWindow(pParent, WB_BORDER | WB_SYSTEMWINDOW)
+{
+}
+
+CommandPopup::~CommandPopup() { disposeOnce(); }
+
+void CommandPopup::dispose() { FloatingWindow::dispose(); }
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/view/CommandPopup.hxx 
b/sfx2/source/view/CommandPopup.hxx
new file mode 100644
index 000000000000..e24b7a829a34
--- /dev/null
+++ b/sfx2/source/view/CommandPopup.hxx
@@ -0,0 +1,81 @@
+/* -*- 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/.
+ *
+ */
+
+#pragma once
+
+#include <vcl/layout.hxx>
+#include <vcl/edit.hxx>
+
+#include <sfx2/dllapi.h>
+#include <sfx2/viewfrm.hxx>
+#include <vcl/floatwin.hxx>
+
+#include <com/sun/star/frame/XFrame.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+
+#include <vcl/InterimItemWindow.hxx>
+#include <vcl/weld.hxx>
+#include <vcl/window.hxx>
+
+struct MenuContent
+{
+    OUString m_aCommandURL;
+    OUString m_aLabel;
+    OUString m_aMenuLabel;
+    std::vector<MenuContent> m_aSubMenuContent;
+};
+
+class SFX2_DLLPUBLIC CommandPopup : public FloatingWindow
+{
+public:
+    explicit CommandPopup(vcl::Window* pWorkWindow);
+
+    ~CommandPopup() override;
+
+    void dispose() override;
+};
+
+class SFX2_DLLPUBLIC CommandListBox final : public InterimItemWindow
+{
+private:
+    CommandPopup& m_rPopUp;
+
+    std::vector<OUString> m_aCommandList;
+    css::uno::Reference<css::frame::XFrame> m_xFrame;
+    css::uno::Reference<css::container::XNameAccess> m_xGlobalCategoryInfo;
+    css::uno::Reference<css::container::XNameAccess> m_xModuleCategoryInfo;
+    css::uno::Reference<css::container::XNameAccess> m_xUICmdDescription;
+    OUString m_sModuleLongName;
+
+    MenuContent m_aMenuContent;
+    OUString m_PreviousText;
+
+    std::unique_ptr<weld::Entry> m_pEntry;
+    std::unique_ptr<weld::TreeView> m_pListBox;
+
+    DECL_LINK(ModifyHdl, weld::Entry&, void);
+
+    void recurse(css::uno::Reference<css::container::XIndexAccess> 
xIndexAccess,
+                 MenuContent& rMenuContent);
+    void findInMenu(MenuContent& aMenuContent, OUString const& rText);
+
+    void dispatchCommandAndClose(OUString const& rCommand);
+    bool EventNotify(NotifyEvent& rNotifyEvent) override;
+
+public:
+    CommandListBox(vcl::Window* pParent, CommandPopup& rPopUp,
+                   css::uno::Reference<css::frame::XFrame> xFrame);
+
+    void initialize();
+
+    void dispose() override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/view/viewfrm.cxx b/sfx2/source/view/viewfrm.cxx
index ccb39350f223..596cdb958eca 100644
--- a/sfx2/source/view/viewfrm.cxx
+++ b/sfx2/source/view/viewfrm.cxx
@@ -25,6 +25,7 @@
 #include <sfx2/viewfrm.hxx>
 #include <sfx2/classificationhelper.hxx>
 #include <sfx2/notebookbar/SfxNotebookBar.hxx>
+#include <svx/svdview.hxx>
 #include <com/sun/star/document/MacroExecMode.hpp>
 #include <com/sun/star/frame/Desktop.hpp>
 #include <com/sun/star/frame/DispatchRecorder.hpp>
@@ -92,6 +93,7 @@
 
 #include <unotools/configmgr.hxx>
 #include <comphelper/sequenceashashmap.hxx>
+#include "CommandPopup.hxx"
 
 using namespace ::com::sun::star;
 using namespace ::com::sun::star::uno;
@@ -2921,8 +2923,26 @@ void SfxViewFrame::MiscExec_Impl( SfxRequest& rReq )
             rReq.Done();
             break;
         }
+        case SID_COMMAND_POPUP:
+        {
+            static VclPtr<CommandPopup> spCommandPopup;
+            static VclPtr<CommandListBox> spCommandListBox;
+
+            if (spCommandListBox)
+                spCommandListBox.disposeAndClear();
+
+            if (spCommandPopup)
+                spCommandPopup.disposeAndClear();
+
+            css::uno::Reference<css::frame::XFrame> 
xFrame(GetFrame().GetFrameInterface(), css::uno::UNO_QUERY);
+            spCommandPopup.reset(VclPtr<CommandPopup>::Create(&GetWindow()));
 
-        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+            
spCommandListBox.reset(VclPtr<CommandListBox>::Create(spCommandPopup.get(), 
*spCommandPopup.get(), xFrame));
+            spCommandListBox->initialize();
+
+            rReq.Done();
+            break;
+        }
         case SID_WIN_FULLSCREEN:
         {
             const SfxBoolItem* pItem = 
rReq.GetArg<SfxBoolItem>(rReq.GetSlot());
diff --git a/sfx2/uiconfig/ui/commandpopup.ui b/sfx2/uiconfig/ui/commandpopup.ui
new file mode 100644
index 000000000000..c6e035b9d7bf
--- /dev/null
+++ b/sfx2/uiconfig/ui/commandpopup.ui
@@ -0,0 +1,78 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.36.0 -->
+<interface domain="sfx">
+  <requires lib="gtk+" version="3.18"/>
+  <object class="GtkTreeStore" id="liststore1">
+    <columns>
+      <!-- column-name text -->
+      <column type="gchararray"/>
+      <!-- column-name id -->
+      <column type="gchararray"/>
+    </columns>
+  </object>
+  <object class="GtkBox" id="CommandBox">
+    <property name="visible">True</property>
+    <property name="can_focus">False</property>
+    <property name="hexpand">True</property>
+    <property name="vexpand">True</property>
+    <property name="orientation">vertical</property>
+    <child>
+      <object class="GtkEntry" id="entry">
+        <property name="visible">True</property>
+        <property name="can_focus">True</property>
+        <property name="placeholder_text" translatable="yes" 
context="commandpopup|entry">Search command</property>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="fill">True</property>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkScrolledWindow">
+        <property name="height_request">400</property>
+        <property name="visible">True</property>
+        <property name="can_focus">True</property>
+        <property name="shadow_type">in</property>
+        <child>
+          <object class="GtkViewport">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <child>
+              <object class="GtkTreeView" id="listBox">
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="model">liststore1</property>
+                <property name="headers_visible">False</property>
+                <property name="headers_clickable">False</property>
+                <property name="enable_search">False</property>
+                <property name="search_column">0</property>
+                <property name="hover_selection">True</property>
+                <property name="show_expanders">False</property>
+                <property name="activate_on_single_click">True</property>
+                <child internal-child="selection">
+                  <object class="GtkTreeSelection"/>
+                </child>
+                <child>
+                  <object class="GtkTreeViewColumn" id="column">
+                    <child>
+                      <object class="GtkCellRendererText" 
id="cellrenderertext"/>
+                      <attributes>
+                        <attribute name="text">0</attribute>
+                      </attributes>
+                    </child>
+                  </object>
+                </child>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">True</property>
+        <property name="fill">True</property>
+        <property name="position">1</property>
+      </packing>
+    </child>
+  </object>
+</interface>
commit a36fa0ee71535d2e2ed841f50af4472bfa4d2b33
Author:     Tomaž Vajngerl <tomaz.vajng...@collabora.co.uk>
AuthorDate: Sat Aug 29 15:42:42 2020 +0200
Commit:     Tomaž Vajngerl <tomaz.vajng...@collabora.co.uk>
CommitDate: Tue Sep 22 08:17:49 2020 +0200

    Add button 'Render Features' to Options
    
    Change-Id: I1a0aa538cdb6d32aa1d0377fd3d032c80bb742a5

diff --git a/cui/source/options/optgdlg.cxx b/cui/source/options/optgdlg.cxx
index 743a64ad4b7f..5940e6ba48b4 100644
--- a/cui/source/options/optgdlg.cxx
+++ b/cui/source/options/optgdlg.cxx
@@ -698,6 +698,7 @@ OfaViewTabPage::OfaViewTabPage(weld::Container* pPage, 
weld::DialogController* p
     , m_xSkiaStatusDisabled(m_xBuilder->weld_label("skiadisabled"))
     , m_xMousePosLB(m_xBuilder->weld_combo_box("mousepos"))
     , m_xMouseMiddleLB(m_xBuilder->weld_combo_box("mousemiddle"))
+    , 
m_xButtonTestRenderFeatures(m_xBuilder->weld_button("button_test_render_features"))
 {
     if (Application::GetToolkitName() == "gtk3")
     {
diff --git a/cui/source/options/optgdlg.hxx b/cui/source/options/optgdlg.hxx
index 5c4177b1f1ba..582a94215d44 100644
--- a/cui/source/options/optgdlg.hxx
+++ b/cui/source/options/optgdlg.hxx
@@ -120,6 +120,8 @@ private:
     std::unique_ptr<weld::ComboBox> m_xMousePosLB;
     std::unique_ptr<weld::ComboBox> m_xMouseMiddleLB;
 
+    std::unique_ptr<weld::Button> m_xButtonTestRenderFeatures;
+
     DECL_LINK(OnAntialiasingToggled, weld::ToggleButton&, void);
     DECL_LINK(OnForceSkiaToggled, weld::ToggleButton&, void);
     DECL_LINK(OnForceSkiaRasterToggled, weld::ToggleButton&, void);
diff --git a/cui/uiconfig/ui/optviewpage.ui b/cui/uiconfig/ui/optviewpage.ui
index 340ccfa735f1..723be734799a 100644
--- a/cui/uiconfig/ui/optviewpage.ui
+++ b/cui/uiconfig/ui/optviewpage.ui
@@ -485,6 +485,18 @@
             <property name="top_attach">0</property>
           </packing>
         </child>
+        <child>
+          <object class="GtkButton" id="button_test_render_features">
+            <property name="label" translatable="yes" 
context="optviewpage|button_test_render_features">Test Render 
Features</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+          </object>
+          <packing>
+            <property name="left_attach">0</property>
+            <property name="top_attach">4</property>
+          </packing>
+        </child>
       </object>
       <packing>
         <property name="left_attach">0</property>
commit 6ee78053f149553a8048838bb94578a2da483e7f
Author:     Tomaž Vajngerl <tomaz.vajng...@collabora.co.uk>
AuthorDate: Sat Aug 29 15:22:03 2020 +0200
Commit:     Tomaž Vajngerl <tomaz.vajng...@collabora.co.uk>
CommitDate: Tue Sep 22 08:17:48 2020 +0200

    Benchmark
    
    Change-Id: I22e0ac54380e2d22606e7b1fd453bed843523a29

diff --git a/Repository.mk b/Repository.mk
index 9641b3bddd10..cd3518417200 100644
--- a/Repository.mk
+++ b/Repository.mk
@@ -74,6 +74,7 @@ $(eval $(call gb_Helper_register_executables,NONE, \
        tiledrendering \
     mtfdemo \
     visualbackendtest \
+    benchmark \
        $(if $(and $(ENABLE_GTK3), $(filter LINUX %BSD SOLARIS,$(OS))), 
gtktiledviewer) \
 ))
 
diff --git a/vcl/Executable_benchmark.mk b/vcl/Executable_benchmark.mk
new file mode 100644
index 000000000000..c72039c13f7b
--- /dev/null
+++ b/vcl/Executable_benchmark.mk
@@ -0,0 +1,56 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+#
+# 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/.
+#
+
+$(eval $(call gb_Executable_Executable,benchmark))
+
+$(eval $(call gb_Executable_use_api,benchmark,\
+    offapi \
+    udkapi \
+))
+
+$(eval $(call gb_Executable_use_external,benchmark,boost_headers))
+
+$(eval $(call gb_Executable_set_include,benchmark,\
+    $$(INCLUDE) \
+    -I$(SRCDIR)/vcl/inc \
+))
+
+$(eval $(call gb_Executable_use_libraries,benchmark,\
+       basegfx \
+    comphelper \
+    cppu \
+    cppuhelper \
+    tl \
+    sal \
+       salhelper \
+    vcl \
+))
+
+$(eval $(call gb_Executable_add_exception_objects,benchmark,\
+    vcl/backendtest/Benchmark \
+))
+
+$(eval $(call gb_Executable_use_static_libraries,benchmark,\
+    vclmain \
+))
+
+ifeq ($(OS),LINUX)
+$(eval $(call gb_Executable_add_libs,benchmark,\
+       -lm \
+       -ldl \
+    -lX11 \
+))
+
+$(eval $(call gb_Executable_use_static_libraries,benchmark,\
+       glxtest \
+))
+endif
+
+# vim: set noet sw=4 ts=4:
diff --git a/vcl/Module_vcl.mk b/vcl/Module_vcl.mk
index 0e7bb1600b0a..5b2dafcfe5d2 100644
--- a/vcl/Module_vcl.mk
+++ b/vcl/Module_vcl.mk
@@ -38,6 +38,7 @@ $(eval $(call gb_Module_add_targets,vcl,\
             $(if $(DISABLE_GUI),, \
                 Executable_vcldemo \
                 Executable_icontest \
+                Executable_benchmark \
                 Executable_visualbackendtest \
                 Executable_mtfdemo ))) \
 ))
diff --git a/vcl/backendtest/Benchmark.cxx b/vcl/backendtest/Benchmark.cxx
new file mode 100644
index 000000000000..9eadd740a4d8
--- /dev/null
+++ b/vcl/backendtest/Benchmark.cxx
@@ -0,0 +1,302 @@
+/* -*- 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 <comphelper/processfactory.hxx>
+#include <cppuhelper/bootstrap.hxx>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/registry/XSimpleRegistry.hpp>
+#include <com/sun/star/ucb/UniversalContentBroker.hpp>
+
+#include <vcl/virdev.hxx>
+#include <vcl/vclmain.hxx>
+#include <vcl/bitmapaccess.hxx>
+#include <vcl/wrkwin.hxx>
+#include <vcl/svapp.hxx>
+
+#include <chrono>
+#include <iostream>
+#include <tools/ScopedNanoTimer.hxx>
+
+using namespace css;
+
+class Benchmark
+{
+    ScopedVclPtr<VirtualDevice> mpVDev;
+    int mnRepeats;
+
+    Size maSource;
+    Size maTarget;
+
+public:
+    Benchmark()
+        : mpVDev(VclPtr<VirtualDevice>::Create())
+        , mnRepeats(2)
+    {
+        mpVDev->SetAntialiasing(AntialiasingFlags::EnableB2dDraw
+                                | AntialiasingFlags::PixelSnapHairline);
+        mpVDev->SetOutputSizePixel(Size(4000, 4000));
+        mpVDev->SetBackground(Wallpaper(COL_LIGHTGRAY));
+    }
+
+    void run()
+    {
+        std::vector<sal_Int64> aCompleteTimes(20, 0);
+
+        mnRepeats = 5;
+        for (long iSize : { 4000, 2000, 1000 })
+        {
+            std::vector<std::pair<OUString, sal_Int64>> aTotalTimes(20);
+
+            maSource = Size(iSize, iSize);
+            maTarget = Size(200, 200);
+
+            for (int i = 0; i < mnRepeats; i++)
+            {
+                size_t a = 0;
+                //benchBitmapScale2(aTotalTimes[a].first, 
aTotalTimes[a].second); a++;
+                //benchBitmapScale4(aTotalTimes[a].first, 
aTotalTimes[a].second); a++;
+                //benchBitmapScale8X(aTotalTimes[a].first, 
aTotalTimes[a].second); a++;
+                //benchBitmapScale8(aTotalTimes[a].first, 
aTotalTimes[a].second); a++;
+                benchBitmapScale24(aTotalTimes[a].first, 
aTotalTimes[a].second);
+                a++;
+                benchBitmapScale24Combo(aTotalTimes[a].first, 
aTotalTimes[a].second);
+                a++;
+                benchBitmapScale32(aTotalTimes[a].first, 
aTotalTimes[a].second);
+                a++;
+                benchBitmapScale32Combo(aTotalTimes[a].first, 
aTotalTimes[a].second);
+                a++;
+
+                /*benchBitmap2(aTotalTimes[a].first, aTotalTimes[a].second); 
a++;
+                benchBitmap4(aTotalTimes[a].first, aTotalTimes[a].second); a++;
+                benchBitmap8X(aTotalTimes[a].first, aTotalTimes[a].second); 
a++;
+                benchBitmap8(aTotalTimes[a].first, aTotalTimes[a].second); a++;
+                benchBitmap24(aTotalTimes[a].first, aTotalTimes[a].second); 
a++;
+                benchBitmap32(aTotalTimes[a].first, aTotalTimes[a].second); 
a++;*/
+            }
+
+            int i = 0;
+            for (auto& rPair : aTotalTimes)
+            {
+                if (!rPair.first.isEmpty())
+                {
+                    aCompleteTimes[i] += rPair.second / double(mnRepeats);
+                    printf("TIME %d: %s - %f\n", i, 
rPair.first.toUtf8().getStr(),
+                           rPair.second / double(mnRepeats));
+                }
+                i++;
+            }
+            printf("\n");
+        }
+        int i = 0;
+        for (auto& rTime : aCompleteTimes)
+        {
+            if (rTime > 0)
+            {
+                printf("TIME %d: %f\n", i, double(rTime));
+                i++;
+            }
+        }
+    }
+
+    void benchBitmapScale2(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "2 Scale";
+        Bitmap aBitmap(maSource, 2, &Bitmap::GetGreyPalette(2));
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer(rName.toUtf8(), 1000);
+        aBitmap.Scale(maTarget, BmpScaleFlag::Super);
+        rTotal += aTimer.stop();
+    }
+
+    void benchBitmapScale4(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "4 Scale";
+        Bitmap aBitmap(maSource, 4, &Bitmap::GetGreyPalette(16));
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer(rName.toUtf8(), 1000);
+        aBitmap.Scale(maTarget, BmpScaleFlag::Super);
+        rTotal += aTimer.stop();
+    }
+
+    void benchBitmapScale8X(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "8X Scale";
+        Bitmap aBitmap(maSource, 8);
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer(rName.toUtf8(), 1000);
+        aBitmap.Scale(maTarget, BmpScaleFlag::Super);
+        rTotal += aTimer.stop();
+    }
+
+    void benchBitmapScale8(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "8 Scale";
+        Bitmap aBitmap(maSource, 8, &Bitmap::GetGreyPalette(256));
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer(rName.toUtf8(), 1000);
+        aBitmap.Scale(maTarget, BmpScaleFlag::Super);
+        rTotal += aTimer.stop();
+    }
+
+    void benchBitmapScale24(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "24 Scale Super";
+        Bitmap aBitmap(maSource, 24);
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer(rName.toUtf8(), 1000);
+        aBitmap.Scale(maTarget, BmpScaleFlag::Super);
+        rTotal += aTimer.stop();
+    }
+
+    void benchBitmapScale24Combo(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "24 Scale Combo";
+        Bitmap aBitmap(maSource, 24);
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer(rName.toUtf8(), 1000);
+        aBitmap.Scale(maTarget, BmpScaleFlag::Combo);
+        rTotal += aTimer.stop();
+    }
+
+    void benchBitmapScale32(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "32 Scale Super";
+        Bitmap aBitmap(maSource, 32);
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer(rName.toUtf8(), 1000);
+        aBitmap.Scale(maTarget, BmpScaleFlag::Super);
+        rTotal += aTimer.stop();
+    }
+
+    void benchBitmapScale32Combo(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "32 Scale Combo";
+        Bitmap aBitmap(maSource, 32);
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer(rName.toUtf8(), 1000);
+        aBitmap.Scale(maTarget, BmpScaleFlag::Combo);
+        rTotal += aTimer.stop();
+    }
+
+    void benchBitmap2(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "2";
+        mpVDev->Erase();
+
+        Bitmap aBitmap(Size(4000, 4000), 2, &Bitmap::GetGreyPalette(2));
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer(rName.toUtf8(), 1000);
+        mpVDev->DrawBitmap(Point(), aBitmap);
+        rTotal += aTimer.stop();
+    }
+
+    void benchBitmap4(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "4";
+        mpVDev->Erase();
+
+        Bitmap aBitmap(Size(4000, 4000), 4, &Bitmap::GetGreyPalette(16));
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer(rName.toUtf8(), 1000);
+        mpVDev->DrawBitmap(Point(), aBitmap);
+        rTotal += aTimer.stop();
+    }
+
+    void benchBitmap8X(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "8X";
+        mpVDev->Erase();
+        Bitmap aBitmap(Size(4000, 4000), 8);
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer(rName.toUtf8(), 1000);
+        mpVDev->DrawBitmap(Point(), aBitmap);
+        rTotal += aTimer.stop();
+    }
+
+    void benchBitmap8(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "8";
+        mpVDev->Erase();
+        Bitmap aBitmap(Size(4000, 4000), 8, &Bitmap::GetGreyPalette(256));
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer(rName.toUtf8(), 1000);
+        mpVDev->DrawBitmap(Point(), aBitmap);
+        rTotal += aTimer.stop();
+    }
+
+    void benchBitmap24(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "24";
+        mpVDev->Erase();
+        Bitmap aBitmap(Size(4000, 4000), 24);
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer(rName.toUtf8(), 1000);
+        mpVDev->DrawBitmap(Point(), aBitmap);
+        rTotal += aTimer.stop();
+    }
+
+    void benchBitmap32(OUString& rName, sal_Int64& rTotal)
+    {
+        rName = "32";
+        mpVDev->Erase();
+        Bitmap aBitmap(Size(4000, 4000), 32);
+        aBitmap.Erase(COL_YELLOW);
+        ScopedNanoTimer aTimer("32", 1000);
+        mpVDev->DrawBitmap(Point(), aBitmap);
+        rTotal += aTimer.stop();
+    }
+};
+
+class BenchmarkApp : public Application
+{
+public:
+    BenchmarkApp() {}
+
+    virtual int Main() override
+    {
+        Benchmark aBenchmark;
+        aBenchmark.run();
+        return 0;
+    }
+
+protected:
+    void Init() override
+    {
+        try
+        {
+            uno::Reference<uno::XComponentContext> xComponentContext
+                = ::cppu::defaultBootstrap_InitialComponentContext();
+            uno::Reference<lang::XMultiServiceFactory> xMSF
+                = 
uno::Reference<lang::XMultiServiceFactory>(xComponentContext->getServiceManager(),
+                                                             uno::UNO_QUERY);
+
+            if (!xMSF.is())
+                Application::Abort("Bootstrap failure - no service manager");
+
+            comphelper::setProcessServiceFactory(xMSF);
+        }
+        catch (const uno::Exception& e)
+        {
+            Application::Abort("Bootstrap exception " + e.Message);
+        }
+    }
+
+    void DeInit() override
+    {
+        uno::Reference<lang::XComponent> 
xComponent(comphelper::getProcessComponentContext(),
+                                                    uno::UNO_QUERY_THROW);
+        xComponent->dispose();
+        comphelper::setProcessServiceFactory(nullptr);
+    }
+};
+
+void vclmain::createApplication() { static BenchmarkApp aApplication; }
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
commit 475e18b369ba81c0add427a0aaa23281c5ea54ec
Author:     Tomaž Vajngerl <tomaz.vajng...@collabora.co.uk>
AuthorDate: Sat Aug 29 11:58:53 2020 +0200
Commit:     Tomaž Vajngerl <tomaz.vajng...@collabora.co.uk>
CommitDate: Tue Sep 22 08:17:48 2020 +0200

    Update BitmapSymmetryCheck check
    
    Change-Id: I5b0080ebc76f7c1cd118cf5317b06ffe1a1c20df

diff --git a/vcl/inc/BitmapSymmetryCheck.hxx b/vcl/inc/BitmapSymmetryCheck.hxx
index faf058923fdf..b225492210ba 100644
--- a/vcl/inc/BitmapSymmetryCheck.hxx
+++ b/vcl/inc/BitmapSymmetryCheck.hxx
@@ -12,18 +12,24 @@
 #define INCLUDED_VCL_INC_BITMAPSYMMETRYCHECK_HXX
 
 #include <vcl/bitmap.hxx>
+#include <vcl/bitmapex.hxx>
 #include <vcl/bitmapaccess.hxx>
+#include <bitmapwriteaccess.hxx>
 
 class VCL_DLLPUBLIC BitmapSymmetryCheck final
 {
-public:
-    BitmapSymmetryCheck();
-    ~BitmapSymmetryCheck();
+private:
+    std::vector<std::pair<Point, Point>> maNonSymmetricPoints;
+    Size maSize;
 
-    static bool check(Bitmap& rBitmap);
+public:
+    BitmapSymmetryCheck() = default;
+    bool check(Bitmap& rBitmap);
+    BitmapEx getErrorBitmap();
 
 private:
-    static bool checkImpl(BitmapReadAccess const * pReadAccess);
+    bool checkImpl(BitmapReadAccess const * pReadAccess);
+    void addNewError(Point const & rPoint1, Point const & rPoint2);
 };
 
 #endif // INCLUDED_VCL_INC_BITMAPSYMMETRYCHECK_HXX
diff --git a/vcl/qa/cppunit/BitmapFilterTest.cxx 
b/vcl/qa/cppunit/BitmapFilterTest.cxx
index 12b32bc316f7..dd07891b9bdc 100644
--- a/vcl/qa/cppunit/BitmapFilterTest.cxx
+++ b/vcl/qa/cppunit/BitmapFilterTest.cxx
@@ -127,7 +127,9 @@ void BitmapFilterTest::testBlurCorrectness()
     CPPUNIT_ASSERT_EQUAL(nBPP, aBitmap24Bit.GetBitCount());
 
     // Check that the bitmap is horizontally and vertically symmetrical
-    CPPUNIT_ASSERT(BitmapSymmetryCheck::check(aBitmap24Bit));
+    BitmapSymmetryCheck aBitmapSymmetryCheck;
+    bool bSymmetryCheckResult = aBitmapSymmetryCheck.check(aBitmap24Bit);
+    CPPUNIT_ASSERT(bSymmetryCheckResult);
 
     {
         Bitmap::ScopedReadAccess aReadAccess(aBitmap24Bit);
diff --git a/vcl/qa/cppunit/BitmapScaleTest.cxx 
b/vcl/qa/cppunit/BitmapScaleTest.cxx
index 277e42adbe1b..b3c14402edab 100644
--- a/vcl/qa/cppunit/BitmapScaleTest.cxx
+++ b/vcl/qa/cppunit/BitmapScaleTest.cxx
@@ -19,19 +19,82 @@
 
 #include <BitmapSymmetryCheck.hxx>
 #include <bitmapwriteaccess.hxx>
+#include <vcl/BitmapTools.hxx>
+
+#include <svdata.hxx>
+#include <salinst.hxx>
 
 namespace
 {
 class BitmapScaleTest : public CppUnit::TestFixture
 {
+    static constexpr const bool mbExportBitmap = true;
+
+    void exportImage(OUString const& rsFilename, Bitmap const& rBitmap)
+    {
+        if (mbExportBitmap)
+        {
+            SvFileStream aStream(rsFilename, StreamMode::WRITE | 
StreamMode::TRUNC);
+            GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter();
+            if (rBitmap.GetBitCount() == 32)
+            {
+                BitmapEx aBitmapConverted;
+                vcl::bitmap::convertBitmap32To24Plus8(BitmapEx(rBitmap), 
aBitmapConverted);
+                rFilter.compressAsPNG(aBitmapConverted, aStream);
+            }
+            else
+            {
+                rFilter.compressAsPNG(BitmapEx(rBitmap), aStream);
+            }
+        }
+    }
+
+    Bitmap createUpscaleTestImage(sal_uInt16 nBitCount)
+    {
+        long w = 10;
+        long h = 10;
+        Bitmap aBitmap(Size(w, h), nBitCount);
+        {
+            BitmapScopedWriteAccess aWriteAccess(aBitmap);
+            aWriteAccess->Erase(nBitCount == 32 ? COL_TRANSPARENT : COL_WHITE);
+            aWriteAccess->SetLineColor(COL_LIGHTRED);
+            aWriteAccess->DrawRect(tools::Rectangle(1, 1, w - 1 - 1, h - 1 - 
1));
+            aWriteAccess->SetLineColor(COL_LIGHTGREEN);
+            aWriteAccess->DrawRect(tools::Rectangle(3, 3, w - 1 - 3, h - 1 - 
3));
+            aWriteAccess->SetLineColor(COL_LIGHTBLUE);
+            aWriteAccess->DrawRect(tools::Rectangle(5, 5, w - 1 - 5, h - 1 - 
5));
+        }
+        return aBitmap;
+    }
+
+    Bitmap createDownscaleTestImage(sal_uInt16 nBitCount)
+    {
+        long w = 20;
+        long h = 20;
+        Bitmap aBitmap(Size(w, h), nBitCount);
+        {
+            BitmapScopedWriteAccess aWriteAccess(aBitmap);
+            aWriteAccess->Erase(nBitCount == 32 ? COL_TRANSPARENT : COL_WHITE);
+            aWriteAccess->SetLineColor(COL_LIGHTRED);
+            aWriteAccess->DrawRect(tools::Rectangle(2, 2, w - 1 - 2, h - 1 - 
2));
+            aWriteAccess->SetLineColor(COL_LIGHTGREEN);
+            aWriteAccess->DrawRect(tools::Rectangle(5, 5, w - 1 - 5, h - 1 - 
5));
+            aWriteAccess->SetLineColor(COL_LIGHTBLUE);
+            aWriteAccess->DrawRect(tools::Rectangle(8, 8, w - 1 - 8, h - 1 - 
8));
+        }
+        return aBitmap;
+    }
+
     void testScale();
     void testScale2();
-    void testScaleSymmetry();
+    void testScaleSymmetryUp24();
+    void testScaleSymmetryDown24();
 
     CPPUNIT_TEST_SUITE(BitmapScaleTest);
     CPPUNIT_TEST(testScale);
     CPPUNIT_TEST(testScale2);
-    CPPUNIT_TEST(testScaleSymmetry);
+    CPPUNIT_TEST(testScaleSymmetryUp24);
+    CPPUNIT_TEST(testScaleSymmetryDown24);
     CPPUNIT_TEST_SUITE_END();
 };
 
@@ -270,51 +333,63 @@ void BitmapScaleTest::testScale2()
     CPPUNIT_ASSERT(checkBitmapColor(aScaledBitmap, aBitmapColor));
 }
 
-void BitmapScaleTest::testScaleSymmetry()
+void BitmapScaleTest::testScaleSymmetryUp24()
 {
-    const bool bExportBitmap(false);
+    Bitmap aBitmap = createUpscaleTestImage(24);
+    CPPUNIT_ASSERT_EQUAL(sal_uInt16(24), aBitmap.GetBitCount());
+    exportImage("~/scale_up_24_before.png", aBitmap);
 
-    Bitmap aBitmap24Bit(Size(10, 10), 24);
-    CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(24), 
aBitmap24Bit.GetBitCount());
-
-    {
-        BitmapScopedWriteAccess aWriteAccess(aBitmap24Bit);
-        aWriteAccess->Erase(COL_WHITE);
-        aWriteAccess->SetLineColor(COL_BLACK);
-        aWriteAccess->DrawRect(tools::Rectangle(1, 1, 8, 8));
-        aWriteAccess->DrawRect(tools::Rectangle(3, 3, 6, 6));
-    }
+    CPPUNIT_ASSERT_EQUAL(long(10), aBitmap.GetSizePixel().Width());
+    CPPUNIT_ASSERT_EQUAL(long(10), aBitmap.GetSizePixel().Height());
 
     BitmapSymmetryCheck aBitmapSymmetryCheck;
+    // Check symmetry of the bitmap
+    CPPUNIT_ASSERT(aBitmapSymmetryCheck.check(aBitmap));
+
+    aBitmap.Scale(2, 2);
+
+    CPPUNIT_ASSERT_EQUAL(long(20), aBitmap.GetSizePixel().Width());
+    CPPUNIT_ASSERT_EQUAL(long(20), aBitmap.GetSizePixel().Height());
+
+    exportImage("~/scale_up_24_after.png", aBitmap);
+
+    // After scaling the bitmap should still be symmetrical. This check 
guarantees that
+    // scaling doesn't misalign the bitmap.
+    bool bSymmetryCheckResult = aBitmapSymmetryCheck.check(aBitmap);
+    if (!bSymmetryCheckResult)
+        exportImage("~/scale_up_24_after_error.png",
+                    aBitmapSymmetryCheck.getErrorBitmap().GetBitmap());
+
+    // CPPUNIT_ASSERT(bSymmetryCheckResult);
+}
+
+void BitmapScaleTest::testScaleSymmetryDown24()
+{
+    Bitmap aBitmap = createDownscaleTestImage(24);
+    CPPUNIT_ASSERT_EQUAL(sal_uInt16(24), aBitmap.GetBitCount());
+    exportImage("~/scale_down_24_before.png", aBitmap);
 
-    CPPUNIT_ASSERT_EQUAL(static_cast<long>(10), 
aBitmap24Bit.GetSizePixel().Width());
-    CPPUNIT_ASSERT_EQUAL(static_cast<long>(10), 
aBitmap24Bit.GetSizePixel().Height());
+    CPPUNIT_ASSERT_EQUAL(long(20), aBitmap.GetSizePixel().Width());
+    CPPUNIT_ASSERT_EQUAL(long(20), aBitmap.GetSizePixel().Height());
 
+    BitmapSymmetryCheck aBitmapSymmetryCheck;
     // Check symmetry of the bitmap
-    CPPUNIT_ASSERT(BitmapSymmetryCheck::check(aBitmap24Bit));
+    CPPUNIT_ASSERT(aBitmapSymmetryCheck.check(aBitmap));
 
-    if (bExportBitmap)
-    {
-        SvFileStream aStream("~/scale_before.png", StreamMode::WRITE | 
StreamMode::TRUNC);
-        GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter();
-        rFilter.compressAsPNG(BitmapEx(aBitmap24Bit), aStream);
-    }
+    aBitmap.Scale(0.5, 0.5);
 
-    aBitmap24Bit.Scale(2, 2, BmpScaleFlag::Fast);
+    exportImage("~/scale_down_24_after.png", aBitmap);
 
-    CPPUNIT_ASSERT_EQUAL(static_cast<long>(20), 
aBitmap24Bit.GetSizePixel().Width());
-    CPPUNIT_ASSERT_EQUAL(static_cast<long>(20), 
aBitmap24Bit.GetSizePixel().Height());
+    CPPUNIT_ASSERT_EQUAL(long(10), aBitmap.GetSizePixel().Width());
+    CPPUNIT_ASSERT_EQUAL(long(10), aBitmap.GetSizePixel().Height());
 
     // After scaling the bitmap should still be symmetrical. This check 
guarantees that
     // scaling doesn't misalign the bitmap.
-    CPPUNIT_ASSERT(BitmapSymmetryCheck::check(aBitmap24Bit));
-
-    if (bExportBitmap)
-    {
-        SvFileStream aStream("~/scale_after.png", StreamMode::WRITE | 
StreamMode::TRUNC);
-        GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter();
-        rFilter.compressAsPNG(BitmapEx(aBitmap24Bit), aStream);
-    }
+    bool bSymmetryCheckResult = aBitmapSymmetryCheck.check(aBitmap);
+    if (!bSymmetryCheckResult)
+        exportImage("~/scale_down_24_after_error.png",
+                    aBitmapSymmetryCheck.getErrorBitmap().GetBitmap());
+    // CPPUNIT_ASSERT(aBitmapSymmetryCheck.check(aBitmap));
 }
 
 } // namespace
diff --git a/vcl/source/bitmap/BitmapSymmetryCheck.cxx 
b/vcl/source/bitmap/BitmapSymmetryCheck.cxx
index 9abb480864e2..b354afc2e5c7 100644
--- a/vcl/source/bitmap/BitmapSymmetryCheck.cxx
+++ b/vcl/source/bitmap/BitmapSymmetryCheck.cxx
@@ -10,12 +10,6 @@
 
 #include <BitmapSymmetryCheck.hxx>
 
-BitmapSymmetryCheck::BitmapSymmetryCheck()
-{}
-
-BitmapSymmetryCheck::~BitmapSymmetryCheck()
-{}
-
 bool BitmapSymmetryCheck::check(Bitmap& rBitmap)
 {
     Bitmap::ScopedReadAccess aReadAccess(rBitmap);
@@ -24,9 +18,13 @@ bool BitmapSymmetryCheck::check(Bitmap& rBitmap)
 
 bool BitmapSymmetryCheck::checkImpl(BitmapReadAccess const * pReadAccess)
 {
+    maNonSymmetricPoints.clear();
+
     long nHeight = pReadAccess->Height();
     long nWidth = pReadAccess->Width();
 
+    maSize = Size(nWidth, nHeight);
+
     long nHeightHalf = nHeight / 2;
     long nWidthHalf = nWidth / 2;
 
@@ -35,22 +33,20 @@ bool BitmapSymmetryCheck::checkImpl(BitmapReadAccess const 
* pReadAccess)
 
     for (long y = 0; y < nHeightHalf; ++y)
     {
-        Scanline pScanlineRead = pReadAccess->GetScanline( y );
-        Scanline pScanlineRead2 = pReadAccess->GetScanline( nHeight - y - 1 );
+        long y2 = nHeight - y - 1;
+
+        Scanline pScanlineRead1 = pReadAccess->GetScanline(y);
+        Scanline pScanlineRead2 = pReadAccess->GetScanline(y2);
         for (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;
-            }
+            long x2 = nWidth - x - 1;
+
+            if (pReadAccess->GetPixelFromData(pScanlineRead1, x) != 
pReadAccess->GetPixelFromData(pScanlineRead2, x))
+                addNewError(Point(x, y), Point(x, y2));
+            if (pReadAccess->GetPixelFromData(pScanlineRead1, x) != 
pReadAccess->GetPixelFromData(pScanlineRead1, x2))
+                addNewError(Point(x, y), Point(x2, y));
+            if (pReadAccess->GetPixelFromData(pScanlineRead1, x) != 
pReadAccess->GetPixelFromData(pScanlineRead2, x2))
+                addNewError(Point(x, y), Point(x2, y2));
         }
     }
 
@@ -58,10 +54,9 @@ bool BitmapSymmetryCheck::checkImpl(BitmapReadAccess const * 
pReadAccess)
     {
         for (long y = 0; y < nHeightHalf; ++y)
         {
-            if (pReadAccess->GetPixel(y, nWidthHalf) != 
pReadAccess->GetPixel(nHeight - y - 1, nWidthHalf))
-            {
-                return false;
-            }
+            long y2 = nHeight - y - 1;
+            if (pReadAccess->GetPixel(y, nWidthHalf) != 
pReadAccess->GetPixel(y2, nWidthHalf))
+                addNewError(Point(nWidthHalf, y), Point(nWidthHalf, y2));
         }
     }
 
@@ -70,14 +65,38 @@ bool BitmapSymmetryCheck::checkImpl(BitmapReadAccess const 
* pReadAccess)
         Scanline pScanlineRead = pReadAccess->GetScanline( nHeightHalf );
         for (long x = 0; x < nWidthHalf; ++x)
         {
-            if (pReadAccess->GetPixelFromData(pScanlineRead, x) != 
pReadAccess->GetPixelFromData(pScanlineRead, nWidth - x - 1))
-            {
-                return false;
-            }
+            long x2 = nWidth - x - 1;
+            BitmapColor c1 = pReadAccess->GetPixelFromData(pScanlineRead, x);
+            BitmapColor c2 = pReadAccess->GetPixelFromData(pScanlineRead, x2);
+            if (c1 != c2)
+                addNewError(Point(x, nHeightHalf), Point(x2, nHeightHalf));
         }
     }
 
-    return true;
+    return maNonSymmetricPoints.empty();
+}
+
+void BitmapSymmetryCheck::addNewError(Point const & rPoint1, Point const & 
rPoint2)
+{
+    maNonSymmetricPoints.emplace_back(rPoint1, rPoint2);
+}
+
+BitmapEx BitmapSymmetryCheck::getErrorBitmap()
+{
+    if (maSize == Size() || maNonSymmetricPoints.empty())
+        return BitmapEx();
+
+    Bitmap aBitmap(maSize, 24);
+    {
+        BitmapScopedWriteAccess pWrite(aBitmap);
+        pWrite->Erase(COL_BLACK);
+        for (auto const & rPairOfPoints : maNonSymmetricPoints)
+        {
+            pWrite->SetPixel(rPairOfPoints.first.Y(), rPairOfPoints.first.X(), 
COL_LIGHTRED);
+            pWrite->SetPixel(rPairOfPoints.second.Y(), 
rPairOfPoints.second.X(), COL_LIGHTGREEN);
+        }
+    }
+    return BitmapEx(aBitmap);
 }
 
 
commit 067d10e12dec7e0f640a09abaddc3f5298e0b1bb
Author:     Tomaž Vajngerl <tomaz.vajng...@collabora.co.uk>
AuthorDate: Sat Aug 29 11:44:21 2020 +0200
Commit:     Tomaž Vajngerl <tomaz.vajng...@collabora.co.uk>
CommitDate: Tue Sep 22 08:17:47 2020 +0200

    Combo image down-scaler and HalfScaler
    
    Change-Id: I2c422f983e378cff47c5534f0f2774ffb41e2a25

diff --git a/include/vcl/bitmap.hxx b/include/vcl/bitmap.hxx
index 9ed602942322..d9ca2307bf4b 100644
--- a/include/vcl/bitmap.hxx
+++ b/include/vcl/bitmap.hxx
@@ -57,7 +57,8 @@ enum class BmpScaleFlag
     Lanczos,
     BiCubic,
     BiLinear,
-    Super // bilinear interpolation when supersampling and averaging when 
subsampling under certain scale
+    Super, // bilinear interpolation when supersampling and averaging when 
subsampling under certain scale
+    Combo
 };
 
 #define BMP_COL_TRANS               Color( 252, 3, 251 )
diff --git a/vcl/Library_vcl.mk b/vcl/Library_vcl.mk
index 3570b4091d7d..78ea89b56d0f 100644
--- a/vcl/Library_vcl.mk
+++ b/vcl/Library_vcl.mk
@@ -357,6 +357,7 @@ $(eval $(call gb_Library_add_exception_objects,vcl,\
     vcl/source/bitmap/BitmapSeparableUnsharpenFilter \
     vcl/source/bitmap/BitmapFastScaleFilter \
     vcl/source/bitmap/BitmapScaleSuperFilter \
+    vcl/source/bitmap/BitmapComboScaleFilter \
     vcl/source/bitmap/BitmapScaleConvolutionFilter \
     vcl/source/bitmap/BitmapSymmetryCheck \
     vcl/source/bitmap/BitmapColorQuantizationFilter \
@@ -365,6 +366,7 @@ $(eval $(call gb_Library_add_exception_objects,vcl,\
     vcl/source/bitmap/checksum \
     vcl/source/bitmap/Octree \
     vcl/source/bitmap/salbmp \
+    vcl/source/bitmap/ScanlineHalfScaler \
     vcl/source/image/Image \
     vcl/source/image/ImageTree \
     vcl/source/image/ImageRepository \
diff --git a/vcl/inc/BitmapComboScaleFilter.hxx 
b/vcl/inc/BitmapComboScaleFilter.hxx
new file mode 100644
index 000000000000..b70254b96c59
--- /dev/null
+++ b/vcl/inc/BitmapComboScaleFilter.hxx
@@ -0,0 +1,52 @@
+/* -*- 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/.
+ */
+
+#ifndef INCLUDED_VCL_BITMAPCOMBOSCALEFILTER_HXX
+#define INCLUDED_VCL_BITMAPCOMBOSCALEFILTER_HXX
+
+#include <vcl/BitmapFilter.hxx>
+
+#include <comphelper/threadpool.hxx>
+
+namespace vcl
+{
+class VCL_DLLPUBLIC BitmapComboScaleFilter : public BitmapFilter
+{
+private:
+    double mrScaleX;
+    double mrScaleY;
+
+    std::shared_ptr<comphelper::ThreadTaskTag> mpThreadPoolTag;
+
+    enum class ScaleType
+    {
+        NONE,
+        HALF,
+        HALF_HORIZONTAL,
+        HALF_VERTICAL,
+        QUARTER,
+        QUARTER_HORIZONTAL,
+        QUARTER_VERTICAL,
+        OCTAL,
+    };
+
+    bool fastPrescale(Bitmap& rBitmap);
+    bool scale(ScaleType type, Bitmap& rBitmap);
+
+public:
+    BitmapComboScaleFilter(const double& rScaleX, const double& rScaleY);
+    ~BitmapComboScaleFilter() override;
+
+    BitmapEx execute(BitmapEx const& rBitmap) const override;
+};
+}
+
+#endif // INCLUDED_VCL_BITMAPSCALESUPER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/inc/bitmap/ScanlineHalfScaler.hxx 
b/vcl/inc/bitmap/ScanlineHalfScaler.hxx
new file mode 100644
index 000000000000..2291944a337e
--- /dev/null
+++ b/vcl/inc/bitmap/ScanlineHalfScaler.hxx
@@ -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/.
+ *
+ */
+
+#ifndef INCLUDED_VCL_INC_BITMAP_SCANLINEHALFSCALER_HXX
+#define INCLUDED_VCL_INC_BITMAP_SCANLINEHALFSCALER_HXX
+
+#include <vcl/bitmapaccess.hxx>
+#include <bitmapwriteaccess.hxx>
+
+#if defined(_MSC_VER)
+#define VCL_FORCEINLINE __forceinline
+#elif defined(__GNUC__)
+#define VCL_FORCEINLINE __attribute__((always_inline)) inline
+#else
+#define VCL_FORCEINLINE inline
+#endif
+
+namespace vcl
+{
+struct VCL_DLLPUBLIC ScaleContext
+{
+    BitmapReadAccess const* const mpSource;
+    BitmapWriteAccess* mpTarget;
+    long mnSourceW;
+    long mnSourceH;
+    long mnTargetW;
+    long mnTargetH;
+    bool mbHMirr;
+    bool mbVMirr;
+
+    VCL_FORCEINLINE Scanline getSourceScanline(long y) { return 
mpSource->GetScanline(y); }
+
+    VCL_FORCEINLINE Scanline getTargetScanline(long y) { return 
mpTarget->GetScanline(y); }
+
+    VCL_FORCEINLINE BitmapColor getSourcePixel(Scanline const& pScanline, long 
x)
+    {
+        return mpSource->GetPixelFromData(pScanline, x);
+    }
+
+    VCL_FORCEINLINE void setTargetPixel(Scanline const& pScanline, long x, 
BitmapColor& rColor)
+    {
+        return mpTarget->SetPixelOnData(pScanline, x, rColor);
+    }
+
+    ScaleContext(BitmapReadAccess* pSource, BitmapWriteAccess* pTarget, long 
nSourceW,
+                 long nTargetW, long nSourceH, long nTargetH, bool bHMirr, 
bool bVMirr)
+        : mpSource(pSource)
+        , mpTarget(pTarget)
+        , mnSourceW(nSourceW)
+        , mnSourceH(nSourceH)
+        , mnTargetW(nTargetW)
+        , mnTargetH(nTargetH)
+        , mbHMirr(bHMirr)
+        , mbVMirr(bVMirr)
+    {
+    }
+};
+
+void scaleHalfGeneralHorizontal(ScaleContext& rContext, long nStartY, long 
nEndY);
+void scaleHalfGeneralVertical(ScaleContext& rContext, long nStartY, long 
nEndY);
+void scaleHalfGeneral(ScaleContext& rContext, long nStartY, long nEndY);
+void scaleQuarterGeneral(ScaleContext& rContext, long nStartY, long nEndY);
+void scaleQuarterGeneralHorizontal(ScaleContext& rContext, long nStartY, long 
nEndY);
+void scaleQuarterGeneralVertical(ScaleContext& rContext, long nStartY, long 
nEndY);
+void scaleOctalGeneral(ScaleContext& rContext, long nStartY, long nEndY);
+
+void scaleOctal32(ScaleContext& rContext, long nStartY, long nEndY);
+void scaleQuarter32_1(ScaleContext& rContext, long nStartY, long nEndY);
+void scaleQuarter32_2(ScaleContext& rContext, long nStartY, long nEndY);
+void scaleQuarter32_SSE(ScaleContext& rContext, long nStartY, long nEndY);
+void scaleHalf32_SSE2(ScaleContext& rContext, long nStartY, long nEndY);
+void scaleHalf32_2(ScaleContext& rContext, long nStartY, long nEndY);
+void scaleHalf32_1(ScaleContext& rContext, long nStartY, long nEndY);
+
+void scaleHalf24(ScaleContext& rContext, long nStartY, long nEndY);
+void scaleHalf32(ScaleContext& rContext, long nStartY, long nEndY);
+
+void scaleOctal24(ScaleContext& rContext, long nStartY, long nEndY);
+void scaleQuarter24(ScaleContext& rContext, long nStartY, long nEndY);
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/BitmapComboScaleFilter.cxx 
b/vcl/source/bitmap/BitmapComboScaleFilter.cxx
new file mode 100644
index 000000000000..338ee75f45d2
--- /dev/null
+++ b/vcl/source/bitmap/BitmapComboScaleFilter.cxx
@@ -0,0 +1,367 @@
+/* -*- 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 <BitmapComboScaleFilter.hxx>
+
+#include <vcl/bitmapaccess.hxx>
+#include <bitmapwriteaccess.hxx>
+#include <BitmapScaleSuperFilter.hxx>
+
+#include <tools/helpers.hxx>
+#include <algorithm>
+#include <memory>
+#include <sal/log.hxx>
+#include <tools/ScopedNanoTimer.hxx>
+#include <tools/cpuid.hxx>
+
+#include <bitmap/ScanlineHalfScaler.hxx>
+
+namespace vcl
+{
+namespace
+{
+constexpr long constScaleThreadStrip = 4;
+
+constexpr bool ALLOW_HORIZONTAL_VERTICAL = false;
+
+typedef void (*ScaleRangeFn)(ScaleContext& rContext, long nStartY, long nEndY);
+
+class ScaleTask : public comphelper::ThreadTask
+{
+    ScaleRangeFn const mpScaleRangeFunction;
+    ScaleContext& mrContext;
+    const long mnStartY;
+    const long mnEndY;
+
+public:
+    explicit ScaleTask(const std::shared_ptr<comphelper::ThreadTaskTag>& pTag,
+                       ScaleRangeFn pScaleRangeFunction, ScaleContext& 
rContext, long nStartY,
+                       long nEndY)
+        : comphelper::ThreadTask(pTag)
+        , mpScaleRangeFunction(pScaleRangeFunction)
+        , mrContext(rContext)
+        , mnStartY(nStartY)
+        , mnEndY(nEndY)
+    {
+    }
+
+    virtual void doWork() override { mpScaleRangeFunction(mrContext, mnStartY, 
mnEndY); }
+};
+
+} // anonymous namespace
+
+BitmapComboScaleFilter::BitmapComboScaleFilter(const double& rScaleX, const 
double& rScaleY)
+    : mrScaleX(rScaleX)
+    , mrScaleY(rScaleY)
+    , mpThreadPoolTag(comphelper::ThreadPool::createThreadTaskTag())
+{
+}
+
+BitmapComboScaleFilter::~BitmapComboScaleFilter() {}
+
+bool BitmapComboScaleFilter::scale(ScaleType eType, Bitmap& rBitmap)
+{
+    if (eType == ScaleType::NONE)
+        return false;
+
+    bool bResult = false;
+
+    const Size aSizePix(rBitmap.GetSizePixel());
+
+    bool bMirrorHorizontal = mrScaleX < 0;
+    bool bMirrorVertical = mrScaleY < 0;
+
+    double nScaleX = 0.0;
+    double nScaleY = 0.0;
+
+    switch (eType)
+    {
+        case ScaleType::OCTAL:
+            nScaleX = 0.125;
+            nScaleY = 0.125;
+            break;
+        case ScaleType::QUARTER:
+            nScaleX = 0.25;
+            nScaleY = 0.25;
+            break;
+        case ScaleType::QUARTER_HORIZONTAL:
+            nScaleX = 0.25;
+            nScaleY = 1.0;
+            break;
+        case ScaleType::QUARTER_VERTICAL:
+            nScaleX = 1.0;
+            nScaleY = 0.25;
+            break;
+        case ScaleType::HALF:
+            nScaleX = 0.5;
+            nScaleY = 0.5;
+            break;
+        case ScaleType::HALF_HORIZONTAL:
+            nScaleX = 0.5;
+            nScaleY = 1.0;
+            break;
+        case ScaleType::HALF_VERTICAL:
+            nScaleX = 1.0;
+            nScaleY = 0.5;
+            break;
+        case ScaleType::NONE:
+            break;
+    }
+
+    const Size aDestinationSize(std::lround(aSizePix.Width() * nScaleX),
+                                std::lround(aSizePix.Height() * nScaleY));
+
+    if (aDestinationSize.Width() == aSizePix.Width()
+        && aDestinationSize.Height() == aSizePix.Height())
+    {
+        return true;
+    }
+
+    if (aDestinationSize.Width() <= 1L || aDestinationSize.Height() <= 1L)
+    {
+        return false;
+    }
+
+    sal_uInt16 nSourceBitcount = rBitmap.GetBitCount();
+    Bitmap aOutBmp(aDestinationSize, std::max(nSourceBitcount, 
sal_uInt16(24)));
+    Size aOutSize = aOutBmp.GetSizePixel();
+
+    const long nStartY = 0;
+    const long nEndY = aDestinationSize.Height() - 1;
+
+    if (!aOutSize.Width() || !aOutSize.Height())
+    {
+        SAL_WARN("vcl.gdi", "bmp creation failed");
+        return false;
+    }
+
+    {
+        Bitmap::ScopedReadAccess pReadAccess(rBitmap);
+        BitmapScopedWriteAccess pWriteAccess(aOutBmp);
+
+        if (pReadAccess && pWriteAccess)
+        {
+            ScaleRangeFn pScaleRangeFn;
+            ScaleContext aContext(pReadAccess.get(), pWriteAccess.get(), 
pReadAccess->Width(),
+                                  pWriteAccess->Width(), pReadAccess->Height(),
+                                  pWriteAccess->Height(), bMirrorVertical, 
bMirrorHorizontal);
+
+            switch (eType)
+            {
+                case ScaleType::OCTAL:
+                {
+                    switch (pReadAccess->GetScanlineFormat())
+                    {
+                        case ScanlineFormat::N24BitTcBgr:
+                        case ScanlineFormat::N24BitTcRgb:
+                            pScaleRangeFn = scaleOctal24;
+                            break;
+                        case ScanlineFormat::N32BitTcRgba:
+                        case ScanlineFormat::N32BitTcBgra:
+                        case ScanlineFormat::N32BitTcArgb:
+                        case ScanlineFormat::N32BitTcAbgr:
+                            pScaleRangeFn = scaleOctal32;
+                            break;
+                        default:
+                            pScaleRangeFn = scaleOctalGeneral;
+                            break;
+                    }
+
+                    break;
+                }
+                case ScaleType::QUARTER:
+                    switch (pReadAccess->GetScanlineFormat())
+                    {
+                        case ScanlineFormat::N24BitTcBgr:
+                        case ScanlineFormat::N24BitTcRgb:
+                            pScaleRangeFn = scaleQuarter24;
+                            break;
+                        case ScanlineFormat::N32BitTcRgba:
+                        case ScanlineFormat::N32BitTcBgra:
+                        case ScanlineFormat::N32BitTcArgb:
+                        case ScanlineFormat::N32BitTcAbgr:
+                            pScaleRangeFn = scaleQuarter32_SSE;
+                            break;
+                        default:
+                            pScaleRangeFn = scaleQuarterGeneral;
+                            break;
+                    }
+
+                    break;
+                case ScaleType::QUARTER_HORIZONTAL:
+                    pScaleRangeFn = scaleQuarterGeneralHorizontal;
+                    break;
+                case ScaleType::QUARTER_VERTICAL:
+                    pScaleRangeFn = scaleQuarterGeneralVertical;
+                    break;
+                case ScaleType::HALF:
+                    switch (pReadAccess->GetScanlineFormat())
+                    {
+                        case ScanlineFormat::N24BitTcBgr:
+                        case ScanlineFormat::N24BitTcRgb:
+                            pScaleRangeFn = scaleHalf24;
+                            break;
+                        case ScanlineFormat::N32BitTcRgba:
+                        case ScanlineFormat::N32BitTcBgra:
+                        case ScanlineFormat::N32BitTcArgb:
+                        case ScanlineFormat::N32BitTcAbgr:
+                            pScaleRangeFn = scaleHalf32_SSE2;
+                            break;
+                        default:
+                            pScaleRangeFn = scaleHalfGeneral;
+                            break;
+                    }
+
+                    break;
+                case ScaleType::HALF_HORIZONTAL:
+                    pScaleRangeFn = scaleHalfGeneralHorizontal;
+                    break;
+                case ScaleType::HALF_VERTICAL:
+                    pScaleRangeFn = scaleHalfGeneralVertical;
+                    break;
+                default:
+                    return false;
+            }
+
+            bool bUseThreads = true;
+
+            static bool bDisableThreadedScaling = 
getenv("VCL_NO_THREAD_SCALE");
+            if (bDisableThreadedScaling)
+            {
+                SAL_INFO("vcl.gdi", "Scale in main thread");
+                bUseThreads = false;
+            }
+
+            if (bUseThreads)
+            {
+                try
+                {
+                    comphelper::ThreadPool& rShared
+                        = comphelper::ThreadPool::getSharedOptimalPool();
+                    // partition and queue work
+                    long nStripYStart = nStartY;
+                    long nStripYEnd = nStripYStart + constScaleThreadStrip - 1;
+
+                    while (nStripYEnd < nEndY)
+                    {
+                        std::unique_ptr<ScaleTask> pTask(new ScaleTask(
+                            mpThreadPoolTag, pScaleRangeFn, aContext, 
nStripYStart, nStripYEnd));
+                        rShared.pushTask(std::move(pTask));
+                        nStripYStart += constScaleThreadStrip;
+                        nStripYEnd += constScaleThreadStrip;
+                    }
+                    if (nStripYStart <= nEndY)
+                    {
+                        std::unique_ptr<ScaleTask> pTask(new ScaleTask(
+                            mpThreadPoolTag, pScaleRangeFn, aContext, 
nStripYStart, nEndY));
+                        rShared.pushTask(std::move(pTask));
+                    }
+                    rShared.waitUntilDone(mpThreadPoolTag);
+                    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);
+
+            bResult = true;
+        }
+    }
+
+    if (bResult)
+    {
+        rBitmap = aOutBmp;
+    }
+    return bResult;
+}
+
+bool BitmapComboScaleFilter::fastPrescale(Bitmap& rBitmap)
+{
+    const Size aSize(rBitmap.GetSizePixel());
+
+    const long nDestinationWidth = std::lround(aSize.Width() * 
std::fabs(mrScaleX));
+    const long nDestinationHeight = std::lround(aSize.Height() * 
std::fabs(mrScaleY));
+
+    bool bResult = false;
+    ScaleType eType = ScaleType::NONE;
+    if (mrScaleX <= 0.125 && mrScaleY <= 0.125)
+    {
+        eType = ScaleType::OCTAL;
+    }
+    else if (mrScaleX <= 0.25 && mrScaleY <= 0.25)
+    {
+        eType = ScaleType::QUARTER;
+    }
+    else if (mrScaleX <= 0.25 && ALLOW_HORIZONTAL_VERTICAL)
+    {
+        eType = ScaleType::QUARTER_HORIZONTAL;
+    }
+    else if (mrScaleY <= 0.25 && ALLOW_HORIZONTAL_VERTICAL)
+    {
+        eType = ScaleType::QUARTER_VERTICAL;
+    }
+    else if (mrScaleX <= 0.5 && mrScaleY <= 0.5)
+    {
+        eType = ScaleType::HALF;
+    }
+    else if (mrScaleX <= 0.5 && ALLOW_HORIZONTAL_VERTICAL)
+    {
+        eType = ScaleType::HALF_HORIZONTAL;
+    }
+    else if (mrScaleY <= 0.5 && ALLOW_HORIZONTAL_VERTICAL)
+    {
+        eType = ScaleType::HALF_VERTICAL;
+    }
+
+    bResult = scale(eType, rBitmap);
+
+    if (bResult)
+    {
+        const Size aNewSize(rBitmap.GetSizePixel());
+        mrScaleX = nDestinationWidth / double(aNewSize.Width());
+        mrScaleY = nDestinationHeight / double(aNewSize.Height());
+        printf("Combo: %ld %ld -> %ld %ld\n", aSize.Width(), aSize.Height(), 
aNewSize.Width(),
+               aNewSize.Height());
+    }
+
+    return bResult;
+}
+
+BitmapEx BitmapComboScaleFilter::execute(BitmapEx const& rBitmapEx) const
+{
+    Bitmap aBitmap(rBitmapEx.GetBitmap());
+
+    while (const_cast<BitmapComboScaleFilter*>(this)->fastPrescale(aBitmap))
+        ;
+
+    BitmapEx aBitmapEx(aBitmap);
+    BitmapScaleSuperFilter aScaleSuper(mrScaleX, mrScaleY);
+    BitmapEx aResult = aScaleSuper.execute(aBitmapEx);
+
+    return aResult;
+}
+
+} // end namespace vcl
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/bitmap/ScanlineHalfScaler.cxx 
b/vcl/source/bitmap/ScanlineHalfScaler.cxx
new file mode 100644
index 000000000000..944559038948
--- /dev/null
+++ b/vcl/source/bitmap/ScanlineHalfScaler.cxx
@@ -0,0 +1,1359 @@
+/* -*- 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 <bitmap/ScanlineHalfScaler.hxx>
+
+#include <vcl/bitmapaccess.hxx>
+#include <bitmapwriteaccess.hxx>
+
+#include <tools/helpers.hxx>
+#include <algorithm>
+#include <memory>
+#include <tools/cpuid.hxx>
+#include <tools/simdsupport.hxx>
+
+#if defined(LO_SSE2_AVAILABLE)
+#include <emmintrin.h>
+#endif
+
+namespace vcl
+{
+namespace
+{
+inline sal_uInt32 Avg2x2(sal_uInt32 a, sal_uInt32 b, sal_uInt32 c, sal_uInt32 
d)
+{
+    // Prepare half-adder work
+    sal_uInt32 sum = a ^ b ^ c;
+    sal_uInt32 carry = (a & b) | (a & c) | (b & c);
+
+    // Before shifting, mask lower order bits of each byte to avoid underflow.
+    sal_uInt32 mask = 0xfefefefe;
+
+    // Add d to sum and divide by 2.
+    sum = (((sum ^ d) & mask) >> 1) + (sum & d);
+
+    // Sum is now shifted into place relative to carry, add them together.
+    return (((sum ^ carry) & mask) >> 1) + (sum & carry);
+}
+}
+
+void scaleHalfGeneralHorizontal(ScaleContext& rContext, long nStartY, long 
nEndY)
+{
+    const long nStartX = 0;
+    const long nEndX = rContext.mnTargetW - 1;
+
+    for (long nY = nStartY; nY <= nEndY; nY++)
+    {
+        Scanline pSourceScanline = rContext.getSourceScanline(nY);
+        Scanline pTargetScanline = rContext.getTargetScanline(nY);
+
+        long nTargetX = 0;
+
+        for (long nX = nStartX; nX <= nEndX; nX++)
+        {
+            long nSourceX = nX * 2;
+
+            BitmapColor aColor0 = rContext.getSourcePixel(pSourceScanline, 
nSourceX);
+            BitmapColor aColor1 = rContext.getSourcePixel(pSourceScanline, 
nSourceX + 1);
+
+            BitmapColor aColorResult((aColor0.GetRed() + aColor1.GetRed()) / 2,
+                                     (aColor0.GetGreen() + aColor1.GetGreen()) 
/ 2,
+                                     (aColor0.GetBlue() + aColor1.GetBlue()) / 
2);
+
+            rContext.setTargetPixel(pTargetScanline, nTargetX++, aColorResult);
+        }
+    }
+}
+
+void scaleHalfGeneralVertical(ScaleContext& rContext, long nStartY, long nEndY)
+{
+    const long nStartX = 0;
+    const long nEndX = rContext.mnTargetW - 1;
+
+    for (long nY = nStartY; nY <= nEndY; nY++)
+    {
+        long nSourceY = nY * 2;
+
+        Scanline pSourceScanline0 = rContext.mpSource->GetScanline(nSourceY);
+        Scanline pSourceScanline1 = rContext.mpSource->GetScanline(nSourceY + 
1);
+
+        Scanline pTargetScanline = rContext.mpTarget->GetScanline(nY);
+
+        long nSourceX = nStartX;
+        long nTargetX = 0;
+
+        for (long nX = nStartX; nX <= nEndX; nX++)
+        {
+            BitmapColor aColor0 = 
rContext.mpSource->GetPixelFromData(pSourceScanline0, nSourceX);
+            BitmapColor aColor1 = 
rContext.mpSource->GetPixelFromData(pSourceScanline1, nSourceX);
+
+            BitmapColor aColorResult((aColor0.GetRed() + aColor1.GetRed()) / 2,
+                                     (aColor0.GetGreen() + aColor1.GetGreen()) 
/ 2,
+                                     (aColor0.GetBlue() + aColor1.GetBlue()) / 
2);
+
+            rContext.mpTarget->SetPixelOnData(pTargetScanline, nTargetX++, 
aColorResult);
+        }
+    }
+}
+
+void scaleHalfGeneral(ScaleContext& rContext, long nStartY, long nEndY)
+{
+    const long nStartX = 0;
+    const long nEndX = rContext.mnTargetW - 1;
+
+    long nSourceY = nStartY * 2;
+
+    for (long nY = nStartY; nY <= nEndY; nY++)
+    {
+        Scanline pSource0 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource1 = rContext.mpSource->GetScanline(nSourceY++);
+
+        Scanline pScanDest = rContext.mpTarget->GetScanline(nY);
+
+        long nTargetX = 0;
+
+        BitmapColor aColor;
+
+        for (long nX = nStartX; nX <= nEndX; nX++)
+        {
+            long nRed = 0;
+            long nGreen = 0;
+            long nBlue = 0;
+            long nAlpha = 0;
+
+            long nSourceX = nX * 2;
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource0, nSourceX);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource0, nSourceX + 
1);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource1, nSourceX);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource1, nSourceX + 
1);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            BitmapColor aColorResult(nRed / 4, nGreen / 4, nBlue / 4, nAlpha / 
4);
+
+            rContext.mpTarget->SetPixelOnData(pScanDest, nTargetX++, 
aColorResult);
+        }
+    }
+}
+
+void scaleQuarterGeneral(ScaleContext& rContext, long nStartY, long nEndY)
+{
+    const long nStartX = 0;
+    const long nEndX = rContext.mnTargetW - 1;
+
+    long nSourceY = nStartY * 4;
+
+    for (long nY = nStartY; nY <= nEndY; nY++)
+    {
+        Scanline pSource0 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource1 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource2 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource3 = rContext.mpSource->GetScanline(nSourceY++);
+
+        Scanline pScanDest = rContext.mpTarget->GetScanline(nY);
+
+        long nTargetX = 0;
+
+        BitmapColor aColor;
+
+        for (long nX = nStartX; nX <= nEndX; nX++)
+        {
+            long nRed = 0;
+            long nGreen = 0;
+            long nBlue = 0;
+            long nAlpha = 0;
+
+            long nSourceX = nX * 4;
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource0, nSourceX);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource0, nSourceX + 
1);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource0, nSourceX + 
2);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource0, nSourceX + 
3);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource1, nSourceX);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource1, nSourceX + 
1);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource1, nSourceX + 
2);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource1, nSourceX + 
3);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource2, nSourceX);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource2, nSourceX + 
1);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource2, nSourceX + 
2);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource2, nSourceX + 
3);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource3, nSourceX);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource3, nSourceX + 
1);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource3, nSourceX + 
2);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            aColor = rContext.mpSource->GetPixelFromData(pSource3, nSourceX + 
3);
+            nRed += aColor.GetRed();
+            nGreen += aColor.GetGreen();
+            nBlue += aColor.GetBlue();
+            nAlpha += aColor.GetAlpha();
+
+            BitmapColor aColorResult(nRed / 16, nGreen / 16, nBlue / 16, 
nAlpha / 16);
+
+            rContext.mpTarget->SetPixelOnData(pScanDest, nTargetX++, 
aColorResult);
+        }
+    }
+}
+
+void scaleQuarterGeneralHorizontal(ScaleContext& rContext, long nStartY, long 
nEndY)
+{
+    const long nStartX = 0;
+    const long nEndX = rContext.mnTargetW - 1;
+
+    for (long nY = nStartY; nY <= nEndY; nY++)
+    {
+        Scanline pSourceScanline = rContext.mpSource->GetScanline(nY);
+        Scanline pTargetScanline = rContext.mpTarget->GetScanline(nY);
+
+        long nTargetX = 0;
+
+        for (long nX = nStartX; nX <= nEndX; nX++)
+        {
+            long nSourceX = nX * 4;
+
+            BitmapColor aColor0 = 
rContext.mpSource->GetPixelFromData(pSourceScanline, nSourceX);
+            BitmapColor aColor1
+                = rContext.mpSource->GetPixelFromData(pSourceScanline, 
nSourceX + 1);
+            BitmapColor aColor2
+                = rContext.mpSource->GetPixelFromData(pSourceScanline, 
nSourceX + 2);
+            BitmapColor aColor3
+                = rContext.mpSource->GetPixelFromData(pSourceScanline, 
nSourceX + 3);
+
+            BitmapColor aColorResult(
+                (aColor0.GetRed() + aColor1.GetRed() + aColor2.GetRed() + 
aColor3.GetRed()) / 4,
+                (aColor0.GetGreen() + aColor1.GetGreen() + aColor2.GetGreen() 
+ aColor3.GetGreen())
+                    / 4,
+                (aColor0.GetBlue() + aColor1.GetBlue() + aColor2.GetBlue() + 
aColor3.GetBlue())
+                    / 4);
+
+            rContext.mpTarget->SetPixelOnData(pTargetScanline, nTargetX++, 
aColorResult);
+        }
+    }
+}
+
+void scaleQuarterGeneralVertical(ScaleContext& rContext, long nStartY, long 
nEndY)
+{
+    const long nStartX = 0;
+    const long nEndX = rContext.mnTargetW - 1;
+
+    for (long nY = nStartY; nY <= nEndY; nY++)
+    {
+        long nSourceY = nY * 4;
+
+        Scanline pSourceScanline0 = rContext.mpSource->GetScanline(nSourceY);
+        Scanline pSourceScanline1 = rContext.mpSource->GetScanline(nSourceY + 
1);
+        Scanline pSourceScanline2 = rContext.mpSource->GetScanline(nSourceY + 
2);
+        Scanline pSourceScanline3 = rContext.mpSource->GetScanline(nSourceY + 
3);
+
+        Scanline pTargetScanline = rContext.mpTarget->GetScanline(nY);
+
+        long nSourceX = nStartX;
+        long nTargetX = 0;
+
+        for (long nX = nStartX; nX <= nEndX; nX++)
+        {
+            BitmapColor aColor0 = 
rContext.mpSource->GetPixelFromData(pSourceScanline0, nSourceX);
+            BitmapColor aColor1 = 
rContext.mpSource->GetPixelFromData(pSourceScanline1, nSourceX);
+            BitmapColor aColor2 = 
rContext.mpSource->GetPixelFromData(pSourceScanline2, nSourceX);
+            BitmapColor aColor3 = 
rContext.mpSource->GetPixelFromData(pSourceScanline3, nSourceX);
+
+            BitmapColor aColorResult(
+                (aColor0.GetRed() + aColor1.GetRed() + aColor2.GetRed() + 
aColor3.GetRed()) / 4,
+                (aColor0.GetGreen() + aColor1.GetGreen() + aColor2.GetGreen() 
+ aColor3.GetGreen())
+                    / 4,
+                (aColor0.GetBlue() + aColor1.GetBlue() + aColor2.GetBlue() + 
aColor3.GetBlue())
+                    / 4);
+
+            rContext.mpTarget->SetPixelOnData(pTargetScanline, nTargetX++, 
aColorResult);
+        }
+    }
+}
+
+void scaleOctalGeneral(ScaleContext& rContext, long nStartY, long nEndY)
+{
+    const long nStartX = 0;
+    const long nEndX = rContext.mnTargetW - 1;
+
+    for (long nY = nStartY; nY <= nEndY; nY++)
+    {
+        long nSourceY = nY * 8;
+
+        Scanline pSource0 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource1 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource2 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource3 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource4 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource5 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource6 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource7 = rContext.mpSource->GetScanline(nSourceY);
+
+        Scanline pTargetScanline = rContext.mpTarget->GetScanline(nY);
+
+        long nTargetX = 0;
+
+        for (long nX = nStartX; nX <= nEndX; nX++)
+        {
+            long nRed = 0;
+            long nGreen = 0;
+            long nBlue = 0;
+            long nAlpha = 0;
+
+            long nSourceX = nX * 8;
+
+            for (long i = 0; i < 8; i++)
+            {
+                BitmapColor aColor = 
rContext.mpSource->GetPixelFromData(pSource0, nSourceX + i);
+                nRed += aColor.GetRed();
+                nGreen += aColor.GetGreen();
+                nBlue += aColor.GetBlue();
+                nAlpha += aColor.GetAlpha();
+            }
+
+            for (long i = 0; i < 8; i++)
+            {
+                BitmapColor aColor = 
rContext.mpSource->GetPixelFromData(pSource1, nSourceX + i);
+                nRed += aColor.GetRed();
+                nGreen += aColor.GetGreen();
+                nBlue += aColor.GetBlue();
+                nAlpha += aColor.GetAlpha();
+            }
+
+            for (long i = 0; i < 8; i++)
+            {
+                BitmapColor aColor = 
rContext.mpSource->GetPixelFromData(pSource2, nSourceX + i);
+                nRed += aColor.GetRed();
+                nGreen += aColor.GetGreen();
+                nBlue += aColor.GetBlue();
+                nAlpha += aColor.GetAlpha();
+            }
+
+            for (long i = 0; i < 8; i++)
+            {
+                BitmapColor aColor = 
rContext.mpSource->GetPixelFromData(pSource3, nSourceX + i);
+                nRed += aColor.GetRed();
+                nGreen += aColor.GetGreen();
+                nBlue += aColor.GetBlue();
+                nAlpha += aColor.GetAlpha();
+            }
+
+            for (long i = 0; i < 8; i++)
+            {
+                BitmapColor aColor = 
rContext.mpSource->GetPixelFromData(pSource4, nSourceX + i);
+                nRed += aColor.GetRed();
+                nGreen += aColor.GetGreen();
+                nBlue += aColor.GetBlue();
+                nAlpha += aColor.GetAlpha();
+            }
+
+            for (long i = 0; i < 8; i++)
+            {
+                BitmapColor aColor = 
rContext.mpSource->GetPixelFromData(pSource5, nSourceX + i);
+                nRed += aColor.GetRed();
+                nGreen += aColor.GetGreen();
+                nBlue += aColor.GetBlue();
+                nAlpha += aColor.GetAlpha();
+            }
+
+            for (long i = 0; i < 8; i++)
+            {
+                BitmapColor aColor = 
rContext.mpSource->GetPixelFromData(pSource6, nSourceX + i);
+                nRed += aColor.GetRed();
+                nGreen += aColor.GetGreen();
+                nBlue += aColor.GetBlue();
+                nAlpha += aColor.GetAlpha();
+            }
+
+            for (long i = 0; i < 8; i++)
+            {
+                BitmapColor aColor = 
rContext.mpSource->GetPixelFromData(pSource7, nSourceX + i);
+                nRed += aColor.GetRed();
+                nGreen += aColor.GetGreen();
+                nBlue += aColor.GetBlue();
+                nAlpha += aColor.GetAlpha();
+            }
+
+            BitmapColor aColorResult(nRed / 64, nGreen / 64, nBlue / 64);
+
+            rContext.mpTarget->SetPixelOnData(pTargetScanline, nTargetX++, 
aColorResult);
+        }
+    }
+}
+
+void scaleOctal32(ScaleContext& rContext, long nStartY, long nEndY)
+{
+    constexpr int constColorComponents = 4;
+    constexpr int constNumberSamples = 4;
+    constexpr int constNumberSamplesSquared = (constNumberSamples * 
constNumberSamples);
+
+    const long nStartX = 0;
+    const long nEndX = rContext.mnTargetW - 1;
+
+    for (long nY = nStartY; nY <= nEndY; nY++)
+    {
+        long nSourceY = nY * constNumberSamples;
+
+        Scanline pSource0 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource1 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource2 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource3 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource4 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource5 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource6 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource7 = rContext.mpSource->GetScanline(nSourceY);
+
+        Scanline pTargetScanline = rContext.mpTarget->GetScanline(nY);
+
+        Scanline pColorPtr;
+
+        for (long nX = nStartX; nX <= nEndX; nX++)
+        {
+            long nComponent1 = 0;
+            long nComponent2 = 0;
+            long nComponent3 = 0;
+            long nComponent4 = 0;
+
+            long nSourceX = nX * constNumberSamples;
+
+            pColorPtr = pSource0 + constColorComponents * nSourceX;
+            for (long i = 0; i < constNumberSamples; i++)
+            {
+                nComponent1 += *pColorPtr;
+                pColorPtr++;
+                nComponent2 += *pColorPtr;
+                pColorPtr++;
+                nComponent3 += *pColorPtr;
+                pColorPtr++;
+                nComponent4 += *pColorPtr;
+                pColorPtr++;
+            }
+
+            pColorPtr = pSource1 + constColorComponents * nSourceX;
+            for (long i = 0; i < constNumberSamples; i++)
+            {
+                nComponent1 += *pColorPtr;
+                pColorPtr++;
+                nComponent2 += *pColorPtr;
+                pColorPtr++;
+                nComponent3 += *pColorPtr;
+                pColorPtr++;
+                nComponent4 += *pColorPtr;
+                pColorPtr++;
+            }
+
+            pColorPtr = pSource2 + constColorComponents * nSourceX;
+            for (long i = 0; i < constNumberSamples; i++)
+            {
+                nComponent1 += *pColorPtr;
+                pColorPtr++;
+                nComponent2 += *pColorPtr;
+                pColorPtr++;
+                nComponent3 += *pColorPtr;
+                pColorPtr++;
+                nComponent4 += *pColorPtr;
+                pColorPtr++;
+            }
+
+            pColorPtr = pSource3 + constColorComponents * nSourceX;
+            for (long i = 0; i < constNumberSamples; i++)
+            {
+                nComponent1 += *pColorPtr;
+                pColorPtr++;
+                nComponent2 += *pColorPtr;
+                pColorPtr++;
+                nComponent3 += *pColorPtr;
+                pColorPtr++;
+                nComponent4 += *pColorPtr;
+                pColorPtr++;
+            }
+
+            pColorPtr = pSource4 + constColorComponents * nSourceX;
+            for (long i = 0; i < constNumberSamples; i++)
+            {
+                nComponent1 += *pColorPtr;
+                pColorPtr++;
+                nComponent2 += *pColorPtr;
+                pColorPtr++;
+                nComponent3 += *pColorPtr;
+                pColorPtr++;
+                nComponent4 += *pColorPtr;
+                pColorPtr++;
+            }
+
+            pColorPtr = pSource5 + constColorComponents * nSourceX;
+            for (long i = 0; i < constNumberSamples; i++)
+            {
+                nComponent1 += *pColorPtr;
+                pColorPtr++;
+                nComponent2 += *pColorPtr;
+                pColorPtr++;
+                nComponent3 += *pColorPtr;
+                pColorPtr++;
+                nComponent4 += *pColorPtr;
+                pColorPtr++;
+            }
+
+            pColorPtr = pSource6 + constColorComponents * nSourceX;
+            for (long i = 0; i < constNumberSamples; i++)
+            {
+                nComponent1 += *pColorPtr;
+                pColorPtr++;
+                nComponent2 += *pColorPtr;
+                pColorPtr++;
+                nComponent3 += *pColorPtr;
+                pColorPtr++;
+                nComponent4 += *pColorPtr;
+                pColorPtr++;
+            }
+
+            pColorPtr = pSource7 + constColorComponents * nSourceX;
+            for (long i = 0; i < constNumberSamples; i++)
+            {
+                nComponent1 += *pColorPtr;
+                pColorPtr++;
+                nComponent2 += *pColorPtr;
+                pColorPtr++;
+                nComponent3 += *pColorPtr;
+                pColorPtr++;
+                nComponent4 += *pColorPtr;
+                pColorPtr++;
+            }
+
+            *pTargetScanline = nComponent1 / constNumberSamplesSquared;
+            pTargetScanline++;
+            *pTargetScanline = nComponent2 / constNumberSamplesSquared;
+            pTargetScanline++;
+            *pTargetScanline = nComponent3 / constNumberSamplesSquared;
+            pTargetScanline++;
+            *pTargetScanline = nComponent4 / constNumberSamplesSquared;
+            pTargetScanline++;
+        }
+    }
+}
+
+void scaleQuarter32_1(ScaleContext& rContext, long nStartY, long nEndY)
+{
+    constexpr int constColorComponents = 4;
+    constexpr int constNumberSamples = 4;
+    constexpr int constNumberSamplesSquared = (constNumberSamples * 
constNumberSamples);
+
+    const long nStartX = 0;
+    const long nEndX = rContext.mnTargetW - 1;
+
+    for (long nY = nStartY; nY <= nEndY; nY++)
+    {
+        long nSourceY = nY * constNumberSamples;
+
+        Scanline pSource0 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource1 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource2 = rContext.mpSource->GetScanline(nSourceY++);
+        Scanline pSource3 = rContext.mpSource->GetScanline(nSourceY);
+
+        Scanline pTargetScanline = rContext.mpTarget->GetScanline(nY);
+
+        Scanline pColorPtr;
+
+        for (long nX = nStartX; nX <= nEndX; nX++)
+        {
+            long nComponent1 = 0;
+            long nComponent2 = 0;
+            long nComponent3 = 0;
+            long nComponent4 = 0;
+
+            long nSourceX = nX * constNumberSamples;
+
+            pColorPtr = pSource0 + constColorComponents * nSourceX;
+            for (long i = 0; i < constNumberSamples; i++)
+            {
+                nComponent1 += *pColorPtr;
+                pColorPtr++;
+                nComponent2 += *pColorPtr;
+                pColorPtr++;
+                nComponent3 += *pColorPtr;
+                pColorPtr++;
+                nComponent4 += *pColorPtr;
+                pColorPtr++;
+            }
+
+            pColorPtr = pSource1 + constColorComponents * nSourceX;
+            for (long i = 0; i < constNumberSamples; i++)
+            {
+                nComponent1 += *pColorPtr;
+                pColorPtr++;
+                nComponent2 += *pColorPtr;
+                pColorPtr++;
+                nComponent3 += *pColorPtr;
+                pColorPtr++;
+                nComponent4 += *pColorPtr;
+                pColorPtr++;
+            }
+
+            pColorPtr = pSource2 + constColorComponents * nSourceX;
+            for (long i = 0; i < constNumberSamples; i++)
+            {
+                nComponent1 += *pColorPtr;
+                pColorPtr++;
+                nComponent2 += *pColorPtr;
+                pColorPtr++;
+                nComponent3 += *pColorPtr;
+                pColorPtr++;
+                nComponent4 += *pColorPtr;
+                pColorPtr++;
+            }
+
+            pColorPtr = pSource3 + constColorComponents * nSourceX;
+            for (long i = 0; i < constNumberSamples; i++)
+            {
+                nComponent1 += *pColorPtr;
+                pColorPtr++;
+                nComponent2 += *pColorPtr;
+                pColorPtr++;
+                nComponent3 += *pColorPtr;
+                pColorPtr++;
+                nComponent4 += *pColorPtr;
+                pColorPtr++;
+            }
+
+            *pTargetScanline = nComponent1 / constNumberSamplesSquared;
+            pTargetScanline++;
+            *pTargetScanline = nComponent2 / constNumberSamplesSquared;
+            pTargetScanline++;
+            *pTargetScanline = nComponent3 / constNumberSamplesSquared;
+            pTargetScanline++;
+            *pTargetScanline = nComponent4 / constNumberSamplesSquared;
+            pTargetScanline++;
+        }
+    }
+}
+
+void scaleQuarter32_2(ScaleContext& rContext, long nStartY, long nEndY)
+{
+    constexpr int constNumberSamples = 4;
+
+    const long nSourceW = rContext.mnSourceW;
+
+    sal_uInt32 nColor00;
+    sal_uInt32 nColor01;
+    sal_uInt32 nColor10;
+    sal_uInt32 nColor11;
+
+    sal_uInt32 nA1;
+    sal_uInt32 nA2;
+    sal_uInt32 nA3;
+    sal_uInt32 nA4;
+
+    for (long nY = nStartY; nY <= nEndY; nY++)
+    {
+        long nSourceY1 = nY * constNumberSamples;
+        long nSourceY2 = nSourceY1 + 1;
+        long nSourceY3 = nSourceY2 + 1;
+        long nSourceY4 = nSourceY3 + 1;
+
+        sal_uInt32* pSource0
+            = 
reinterpret_cast<sal_uInt32*>(rContext.mpSource->GetScanline(nSourceY1));
+        sal_uInt32* pSource1
+            = 
reinterpret_cast<sal_uInt32*>(rContext.mpSource->GetScanline(nSourceY2));
+        sal_uInt32* pSource2
+            = 
reinterpret_cast<sal_uInt32*>(rContext.mpSource->GetScanline(nSourceY3));
+        sal_uInt32* pSource3
+            = 
reinterpret_cast<sal_uInt32*>(rContext.mpSource->GetScanline(nSourceY4));
+
+        sal_uInt32* pTarget = 
reinterpret_cast<sal_uInt32*>(rContext.mpTarget->GetScanline(nY));
+
+        for (long nSourceX = 0; nSourceX < nSourceW; nSourceX += 
constNumberSamples)
+        {
+            nColor00 = *pSource0;
+            pSource0++;
+            nColor01 = *pSource0;
+            pSource0++;
+
+            nColor10 = *pSource1;
+            pSource1++;
+            nColor11 = *pSource1;
+            pSource1++;
+
+            nA1 = Avg2x2(nColor00, nColor01, nColor10, nColor11);
+
+            nColor00 = *pSource0;
+            pSource0++;
+            nColor01 = *pSource0;
+            pSource0++;
+
+            nColor10 = *pSource1;
+            pSource1++;
+            nColor11 = *pSource1;
+            pSource1++;
+
+            nA2 = Avg2x2(nColor00, nColor01, nColor10, nColor11);
+
+            nColor00 = *pSource2;
+            pSource2++;
+            nColor01 = *pSource2;
+            pSource2++;
+
+            nColor10 = *pSource3;
+            pSource3++;
+            nColor11 = *pSource3;
+            pSource3++;
+
+            nA3 = Avg2x2(nColor00, nColor01, nColor10, nColor11);
+
+            nColor00 = *pSource2;
+            pSource2++;
+            nColor01 = *pSource2;
+            pSource2++;
+
+            nColor10 = *pSource3;
+            pSource3++;
+            nColor11 = *pSource3;
+            pSource3++;
+
+            nA4 = Avg2x2(nColor00, nColor01, nColor10, nColor11);
+
+            *pTarget = Avg2x2(nA1, nA2, nA3, nA4);
+            pTarget++;
+        }
+    }
+}
+
+VCL_FORCEINLINE __m128i _mm_not_si128(__m128i arg)
+{
+    __m128i minusone = _mm_set1_epi32(0xffffffff);
+    return _mm_xor_si128(arg, minusone);
+}
+
+VCL_FORCEINLINE __m128i avg_sse2_8x2(__m128i* a, __m128i* b, __m128i* c, 
__m128i* d)
+{
+#define shuffle_si128(arga, argb, imm)                                         
                    \
+    _mm_castps_si128(_mm_shuffle_ps(_mm_castsi128_ps((arga)), 
_mm_castsi128_ps((argb)), (imm)));
+
+    __m128i t = shuffle_si128(*a, *b, _MM_SHUFFLE(2, 0, 2, 0));
+    *b = shuffle_si128(*a, *b, _MM_SHUFFLE(3, 1, 3, 1));
+    *a = t;
+    t = shuffle_si128(*c, *d, _MM_SHUFFLE(2, 0, 2, 0));
+    *d = shuffle_si128(*c, *d, _MM_SHUFFLE(3, 1, 3, 1));
+    *c = t;
+
+#undef shuffle_si128
+
+    __m128i sum = _mm_xor_si128(*a, _mm_xor_si128(*b, *c));
+
+    __m128i carry = _mm_or_si128(_mm_and_si128(*a, *b),
+                                 _mm_or_si128(_mm_and_si128(*a, *c), 
_mm_and_si128(*b, *c)));
+
+    sum = _mm_avg_epu8(_mm_not_si128(sum), _mm_not_si128(*d));
+

... etc. - the rest is truncated
_______________________________________________
Libreoffice-commits mailing list
libreoffice-comm...@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/libreoffice-commits