Repository.mk | 1 include/vcl/bitmap.hxx | 3 vcl/Executable_benchmark.mk | 56 + vcl/Library_vcl.mk | 2 vcl/Module_vcl.mk | 1 vcl/backendtest/Benchmark.cxx | 302 ++++++ vcl/inc/BitmapComboScaleFilter.hxx | 52 + vcl/inc/BitmapSymmetryCheck.hxx | 16 vcl/inc/bitmap/ScanlineHalfScaler.hxx | 91 + vcl/qa/cppunit/BitmapFilterTest.cxx | 4 vcl/qa/cppunit/BitmapScaleTest.cxx | 143 ++ vcl/source/bitmap/BitmapComboScaleFilter.cxx | 367 +++++++ vcl/source/bitmap/BitmapSymmetryCheck.cxx | 77 - vcl/source/bitmap/ScanlineHalfScaler.cxx | 1359 +++++++++++++++++++++++++++ vcl/source/gdi/bitmap3.cxx | 4 15 files changed, 2408 insertions(+), 70 deletions(-)
New commits: commit 31f83f8b36c40efc13597048dfd6733360f7b25d Author: Tomaž Vajngerl <[email protected]> AuthorDate: Sat Aug 29 15:22:03 2020 +0200 Commit: Tomaž Vajngerl <[email protected]> CommitDate: Sat Aug 29 15:22:03 2020 +0200 Benchmark Change-Id: I22e0ac54380e2d22606e7b1fd453bed843523a29 diff --git a/Repository.mk b/Repository.mk index dbb628f2a6b3..c607831919f5 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 b1c52aa142ee5f2afee34afa8f25b8e39dfc490c Author: Tomaž Vajngerl <[email protected]> AuthorDate: Sat Aug 29 11:58:53 2020 +0200 Commit: Tomaž Vajngerl <[email protected]> CommitDate: Sat Aug 29 12:06:23 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 da1beb8ee993f33cc04e1cced0a697ca5a517af0 Author: Tomaž Vajngerl <[email protected]> AuthorDate: Sat Aug 29 11:44:21 2020 +0200 Commit: Tomaž Vajngerl <[email protected]> CommitDate: Sat Aug 29 11:44:21 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 214c66b14197..1c6e2001fbd1 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)); + + return _mm_not_si128(_mm_avg_epu8(sum, _mm_not_si128(carry))); +} + +void scaleQuarter32_SSE(ScaleContext& rContext, long nStartY, long nEndY) +{ + constexpr int constNumberSamples = 4; + + const long nSourceW = rContext.mnSourceW; + + __m128i nColor00; + __m128i nColor01; + __m128i nColor02; + __m128i nColor03; + + __m128i nColor10; + __m128i nColor11; + __m128i nColor12; + __m128i nColor13; + + __m128i nA1; + __m128i nA2; + __m128i nA3; + __m128i nA4; + + for (long nY = nStartY; nY <= nEndY; nY++) + { + long nSourceY1 = nY * constNumberSamples; + long nSourceY2 = nSourceY1 + 1; + long nSourceY3 = nSourceY2 + 1; + long nSourceY4 = nSourceY3 + 1; + + __m128i* pSource0 = reinterpret_cast<__m128i*>(rContext.mpSource->GetScanline(nSourceY1)); + __m128i* pSource1 = reinterpret_cast<__m128i*>(rContext.mpSource->GetScanline(nSourceY2)); + __m128i* pSource2 = reinterpret_cast<__m128i*>(rContext.mpSource->GetScanline(nSourceY3)); + __m128i* pSource3 = reinterpret_cast<__m128i*>(rContext.mpSource->GetScanline(nSourceY4)); + + __m128i* pTarget = reinterpret_cast<__m128i*>(rContext.mpTarget->GetScanline(nY)); + + for (long nSourceX = 0; nSourceX < nSourceW; nSourceX += constNumberSamples * 4) + { + nColor00 = _mm_loadu_si128(pSource0); + pSource0++; + nColor01 = _mm_loadu_si128(pSource0); + pSource0++; + nColor02 = _mm_loadu_si128(pSource0); + pSource0++; + nColor03 = _mm_loadu_si128(pSource0); + pSource0++; + + nColor10 = _mm_loadu_si128(pSource1); + pSource1++; + nColor11 = _mm_loadu_si128(pSource1); + pSource1++; + nColor12 = _mm_loadu_si128(pSource1); + pSource1++; + nColor13 = _mm_loadu_si128(pSource1); + pSource1++; + + nA1 = avg_sse2_8x2(&nColor00, &nColor01, &nColor10, &nColor11); + nA2 = avg_sse2_8x2(&nColor02, &nColor03, &nColor12, &nColor13); + + nColor00 = _mm_loadu_si128(pSource2); + pSource2++; + nColor01 = _mm_loadu_si128(pSource2); + pSource2++; + nColor02 = _mm_loadu_si128(pSource2); + pSource2++; + nColor03 = _mm_loadu_si128(pSource2); + pSource2++; + + nColor10 = _mm_loadu_si128(pSource3); + pSource3++; + nColor11 = _mm_loadu_si128(pSource3); + pSource3++; + nColor12 = _mm_loadu_si128(pSource3); + pSource3++; + nColor13 = _mm_loadu_si128(pSource3); + pSource3++; + + nA3 = avg_sse2_8x2(&nColor00, &nColor01, &nColor10, &nColor11); + nA4 = avg_sse2_8x2(&nColor02, &nColor03, &nColor12, &nColor13); + + _mm_storeu_si128(pTarget, avg_sse2_8x2(&nA1, &nA2, &nA3, &nA4)); + pTarget++; + } + } +} + +void scaleHalf32_SSE2(ScaleContext& rContext, long nStartY, long nEndY) +{ + constexpr int constNumberSamples = 2; + + const long nSourceW = rContext.mnSourceW; + + __m128i nColor00; + __m128i nColor01; + __m128i nColor10; + __m128i nColor11; + + for (long nY = nStartY; nY <= nEndY; nY++) + { + long nSourceY1 = nY * constNumberSamples; + long nSourceY2 = nSourceY1 + 1; + + __m128i* pSource0 = reinterpret_cast<__m128i*>(rContext.mpSource->GetScanline(nSourceY1)); + __m128i* pSource1 = reinterpret_cast<__m128i*>(rContext.mpSource->GetScanline(nSourceY2)); + + __m128i* pTarget = reinterpret_cast<__m128i*>(rContext.mpTarget->GetScanline(nY)); + + for (long nSourceX = 0; nSourceX < nSourceW; nSourceX += constNumberSamples * 4) + { + nColor00 = _mm_loadu_si128(pSource0); + pSource0++; + nColor01 = _mm_loadu_si128(pSource0); + pSource0++; + nColor10 = _mm_loadu_si128(pSource1); + pSource1++; + nColor11 = _mm_loadu_si128(pSource1); + pSource1++; + + _mm_storeu_si128(pTarget, avg_sse2_8x2(&nColor00, &nColor01, &nColor10, &nColor11)); + pTarget++; + } + } +} + +void scaleHalf32_2(ScaleContext& rContext, long nStartY, long nEndY) +{ + constexpr int constNumberSamples = 2; + + const long nSourceW = rContext.mnSourceW; + + sal_uInt32 nColor00; + sal_uInt32 nColor01; + sal_uInt32 nColor10; + sal_uInt32 nColor11; + for (long nY = nStartY; nY <= nEndY; nY++) + { + long nSourceY1 = nY * constNumberSamples; + long nSourceY2 = nSourceY1 + 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* 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++; + + *pTarget = Avg2x2(nColor00, nColor01, nColor10, nColor11); + pTarget++; + } + } +} + +void scaleHalf32_1(ScaleContext& rContext, long nStartY, long nEndY) +{ + constexpr int constColorComponents = 4; + constexpr int constNumberSamples = 2; + constexpr int constNumberSamplesSquared = (constNumberSamples * constNumberSamples); + + const long nStartX = 0; + const long nEndX = rContext.mnTargetW - 1; + + long nComponent1 = 0; + long nComponent2 = 0; + long nComponent3 = 0; + long nComponent4 = 0; + + for (long nY = nStartY; nY <= nEndY; nY++) + { + long nSourceY = nY * constNumberSamples; + + Scanline pSource0 = rContext.mpSource->GetScanline(nSourceY++); + Scanline pSource1 = rContext.mpSource->GetScanline(nSourceY); + + Scanline pTargetScanline = rContext.mpTarget->GetScanline(nY); + + Scanline pColorPtr; + + for (long nX = nStartX; nX <= nEndX; nX++) + { + nComponent1 = 0; + nComponent2 = 0; + nComponent3 = 0; + 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++; + } + + *pTargetScanline = nComponent1 / constNumberSamplesSquared; + pTargetScanline++; + *pTargetScanline = nComponent2 / constNumberSamplesSquared; + pTargetScanline++; + *pTargetScanline = nComponent3 / constNumberSamplesSquared; + pTargetScanline++; + *pTargetScanline = nComponent4 / constNumberSamplesSquared; + pTargetScanline++; + } + } +} + +template <int constColorComponents> +void scaleHalf32or24(ScaleContext& rContext, long nStartY, long nEndY) +{ + constexpr int constNumberSamples = 2; + constexpr int constNumberSamplesSquared = constNumberSamples * constNumberSamples; + + const long nSourceW = rContext.mnSourceW; + + std::array<long, constColorComponents> aComponents; + + for (long nY = nStartY; nY <= nEndY; nY++) + { + long nSourceY1 = nY * constNumberSamples; + long nSourceY2 = nSourceY1 + 1; + + Scanline pSource0 = rContext.mpSource->GetScanline(nSourceY1); + Scanline pSource1 = rContext.mpSource->GetScanline(nSourceY2); + Scanline pTargetScanline = rContext.mpTarget->GetScanline(nY); + + long nSourceX; + for (nSourceX = 0; nSourceX < nSourceW; nSourceX += constNumberSamples) + { + aComponents.fill(0); + long i; + long c; + + for (i = 0; i < constNumberSamples; i++) + { + for (c = 0; c < constColorComponents; c++) + { + aComponents[c] += *pSource0; + pSource0++; + } + } + + for (i = 0; i < constNumberSamples; i++) + { + for (c = 0; c < constColorComponents; c++) + { + aComponents[c] += *pSource1; + pSource1++; + } + } + + for (c = 0; c < constColorComponents; c++) + { + *pTargetScanline = aComponents[c] / constNumberSamplesSquared; + pTargetScanline++; + } + } + } +} + +void scaleHalf32(ScaleContext& rContext, long nStartY, long nEndY) +{ + scaleHalf32or24<4>(rContext, nStartY, nEndY); +} + +void scaleHalf24(ScaleContext& rContext, long nStartY, long nEndY) +{ + scaleHalf32or24<3>(rContext, nStartY, nEndY); +} + +void scaleOctal24(ScaleContext& rContext, long nStartY, long nEndY) +{ + constexpr int constColorComponents = 3; + constexpr int constNumberSamples = 8; + 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 nSourceX = nX * constNumberSamples; + + pColorPtr = pSource0 + constColorComponents * nSourceX; + for (long i = 0; i < constNumberSamples; i++) + { + nComponent1 += *pColorPtr; + pColorPtr++; + nComponent2 += *pColorPtr; + pColorPtr++; + nComponent3 += *pColorPtr; + pColorPtr++; + } + + pColorPtr = pSource1 + constColorComponents * nSourceX; + for (long i = 0; i < constNumberSamples; i++) + { + nComponent1 += *pColorPtr; + pColorPtr++; + nComponent2 += *pColorPtr; + pColorPtr++; + nComponent3 += *pColorPtr; + pColorPtr++; + } + + pColorPtr = pSource2 + constColorComponents * nSourceX; + for (long i = 0; i < constNumberSamples; i++) + { + nComponent1 += *pColorPtr; + pColorPtr++; + nComponent2 += *pColorPtr; + pColorPtr++; + nComponent3 += *pColorPtr; + pColorPtr++; + } + + pColorPtr = pSource3 + constColorComponents * nSourceX; + for (long i = 0; i < constNumberSamples; i++) + { + nComponent1 += *pColorPtr; + pColorPtr++; + nComponent2 += *pColorPtr; + pColorPtr++; + nComponent3 += *pColorPtr; + pColorPtr++; + } + + pColorPtr = pSource4 + constColorComponents * nSourceX; + for (long i = 0; i < constNumberSamples; i++) + { + nComponent1 += *pColorPtr; + pColorPtr++; + nComponent2 += *pColorPtr; + pColorPtr++; + nComponent3 += *pColorPtr; + pColorPtr++; + } + + pColorPtr = pSource5 + constColorComponents * nSourceX; + for (long i = 0; i < constNumberSamples; i++) + { + nComponent1 += *pColorPtr; + pColorPtr++; + nComponent2 += *pColorPtr; + pColorPtr++; + nComponent3 += *pColorPtr; + pColorPtr++; + } + + pColorPtr = pSource6 + constColorComponents * nSourceX; + for (long i = 0; i < constNumberSamples; i++) + { + nComponent1 += *pColorPtr; + pColorPtr++; + nComponent2 += *pColorPtr; + pColorPtr++; + nComponent3 += *pColorPtr; + pColorPtr++; + } + + pColorPtr = pSource7 + constColorComponents * nSourceX; + for (long i = 0; i < constNumberSamples; i++) + { + nComponent1 += *pColorPtr; + pColorPtr++; + nComponent2 += *pColorPtr; + pColorPtr++; + nComponent3 += *pColorPtr; + pColorPtr++; + } + + *pTargetScanline = nComponent1 / constNumberSamplesSquared; + pTargetScanline++; + *pTargetScanline = nComponent2 / constNumberSamplesSquared; + pTargetScanline++; + *pTargetScanline = nComponent3 / constNumberSamplesSquared; + pTargetScanline++; + } + } +} + +void scaleQuarter24(ScaleContext& rContext, long nStartY, long nEndY) +{ + constexpr int constColorComponents = 3; + 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 nSourceX = nX * constNumberSamples; + + pColorPtr = pSource0 + constColorComponents * nSourceX; + for (long i = 0; i < constNumberSamples; i++) + { + nComponent1 += *pColorPtr; + pColorPtr++; + nComponent2 += *pColorPtr; + pColorPtr++; + nComponent3 += *pColorPtr; + pColorPtr++; + } + + pColorPtr = pSource1 + constColorComponents * nSourceX; + for (long i = 0; i < constNumberSamples; i++) + { + nComponent1 += *pColorPtr; + pColorPtr++; + nComponent2 += *pColorPtr; + pColorPtr++; + nComponent3 += *pColorPtr; + pColorPtr++; + } + + pColorPtr = pSource2 + constColorComponents * nSourceX; + for (long i = 0; i < constNumberSamples; i++) + { + nComponent1 += *pColorPtr; + pColorPtr++; + nComponent2 += *pColorPtr; + pColorPtr++; + nComponent3 += *pColorPtr; + pColorPtr++; + } + + pColorPtr = pSource3 + constColorComponents * nSourceX; + for (long i = 0; i < constNumberSamples; i++) + { + nComponent1 += *pColorPtr; + pColorPtr++; + nComponent2 += *pColorPtr; + pColorPtr++; + nComponent3 += *pColorPtr; + pColorPtr++; + } + + *pTargetScanline = nComponent1 / constNumberSamplesSquared; + pTargetScanline++; + *pTargetScanline = nComponent2 / constNumberSamplesSquared; + pTargetScanline++; + *pTargetScanline = nComponent3 / constNumberSamplesSquared; + pTargetScanline++; + } + } +} + +} // namespace vcl + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/gdi/bitmap3.cxx b/vcl/source/gdi/bitmap3.cxx index 3e9972569a16..1f86792852b6 100644 --- a/vcl/source/gdi/bitmap3.cxx +++ b/vcl/source/gdi/bitmap3.cxx @@ -35,6 +35,7 @@ #include <vcl/BitmapMonochromeFilter.hxx> #include <BitmapScaleSuperFilter.hxx> +#include <BitmapComboScaleFilter.hxx> #include <BitmapScaleConvolutionFilter.hxx> #include <BitmapFastScaleFilter.hxx> #include <BitmapInterpolateScaleFilter.hxx> @@ -752,6 +753,9 @@ bool Bitmap::Scale( const double& rScaleX, const double& rScaleY, BmpScaleFlag n case BmpScaleFlag::BiLinear: bRetval = BitmapFilter::Filter(aBmpEx, vcl::BitmapScaleBilinearFilter(rScaleX, rScaleY)); break; + case BmpScaleFlag::Combo: + bRetval = BitmapFilter::Filter(aBmpEx, vcl::BitmapComboScaleFilter(rScaleX, rScaleY)); + break; } if (bRetval) _______________________________________________ Libreoffice-commits mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/libreoffice-commits
