AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
1dd0c4bf1a
qt5base-lts/tests/benchmarks/gui/image/qimageconversion/tst_qimageconversion.cpp

406 lines
16 KiB
C++
Raw Normal View History

Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
/****************************************************************************
**
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I42a473ddc97101492a60b9287d90979d9eb35ae1 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-15 12:36:27 +00:00
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
**
** This file is part of the test suite of the Qt Toolkit.
**
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I42a473ddc97101492a60b9287d90979d9eb35ae1 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-15 12:36:27 +00:00
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
Change copyrights from Nokia to Digia Change copyrights and license headers from Nokia to Digia Change-Id: If1cc974286d29fd01ec6c19dd4719a67f4c3f00e Reviewed-by: Lars Knoll <lars.knoll@digia.com> Reviewed-by: Sergio Ahumada <sergio.ahumada@digia.com>
2012-09-19 12:28:29 +00:00
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
Update copyright headers Qt copyrights are now in The Qt Company, so we could update the source code headers accordingly. In the same go we should also fix the links to point to qt.io. Outdated header.LGPL removed (use header.LGPL21 instead) Old header.LGPL3 renamed to header.LGPL3-COMM to match actual licensing combination. New header.LGPL-COMM taken in the use file which were using old header.LGPL3 (src/plugins/platforms/android/extract.cpp) Added new header.LGPL3 containing Commercial + LGPLv3 + GPLv2 license combination Change-Id: I6f49b819a8a20cc4f88b794a8f6726d975e8ffbe Reviewed-by: Matti Paaso <matti.paaso@theqtcompany.com>
2015-01-28 08:44:43 +00:00
** a written agreement between you and The Qt Company. For licensing terms
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I42a473ddc97101492a60b9287d90979d9eb35ae1 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-15 12:36:27 +00:00
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
Change copyrights from Nokia to Digia Change copyrights and license headers from Nokia to Digia Change-Id: If1cc974286d29fd01ec6c19dd4719a67f4c3f00e Reviewed-by: Lars Knoll <lars.knoll@digia.com> Reviewed-by: Sergio Ahumada <sergio.ahumada@digia.com>
2012-09-19 12:28:29 +00:00
**
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I42a473ddc97101492a60b9287d90979d9eb35ae1 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-15 12:36:27 +00:00
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <qtest.h>
#include <QImage>
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
Q_DECLARE_METATYPE(QImage::Format)
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
class tst_QImageConversion : public QObject
{
Q_OBJECT
private slots:
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
void convertRgb888ToRgb32_data();
void convertRgb888ToRgb32();
Optimize fallback RGB888 to RGB32 conversion Improves the conversion from RGB888 to RGB32 on platforms without SIMD versions. This includes the fallback used on non-neon ARM devices. Besides image conversion the routine is also used for decoding JPEG. On x86 this version is within 0.7x of the speed of the SSSE3 version. Change-Id: Id131994d7c3c4f879d89e80f9d6c435bb5535ed7 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-19 10:20:52 +00:00
void convertRgb888ToRgbx8888_data();
void convertRgb888ToRgbx8888();
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
void convertRgb32ToRgb888_data();
void convertRgb32ToRgb888();
Add missing RGB32 <-> RGB30 convertions Completes the inplace converters so that we can rely on inplace conversions to succede as long as the image depth is the same. Change-Id: Ia1ae34b5de1bc16e87ff5403bdacfcae44a22791 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-27 13:03:09 +00:00
void convertRgb16_data();
void convertRgb16();
void convertRgb32_data();
void convertRgb32();
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
void convertGeneric_data();
void convertGeneric();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
void convertGenericInplace_data();
void convertGenericInplace();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
private:
QImage generateImageRgb888(int width, int height);
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
QImage generateImageRgb16(int width, int height);
QImage generateImageRgb32(int width, int height);
QImage generateImageArgb32(int width, int height);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
};
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
void tst_QImageConversion::convertRgb888ToRgb32_data()
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
{
QTest::addColumn<QImage>("inputImage");
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
// height = 5000 to get interesting timing.
// 3 pixels wide -> smaller than regular vector of 128bits
QTest::newRow("width: 3px; height: 5000px;") << generateImageRgb888(3, 5000);
// 8 pixels wide -> potential for 2 vectors
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
QTest::newRow("width: 8px; height: 5000px;") << generateImageRgb888(8, 5000);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
// 16 pixels, minimum for the SSSE3 implementation
QTest::newRow("width: 16px; height: 5000px;") << generateImageRgb888(16, 5000);
Optimize fallback RGB888 to RGB32 conversion Improves the conversion from RGB888 to RGB32 on platforms without SIMD versions. This includes the fallback used on non-neon ARM devices. Besides image conversion the routine is also used for decoding JPEG. On x86 this version is within 0.7x of the speed of the SSSE3 version. Change-Id: Id131994d7c3c4f879d89e80f9d6c435bb5535ed7 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-19 10:20:52 +00:00
// 200 pixels, more realistic use case
QTest::newRow("width: 200px; height: 5000px;") << generateImageRgb888(200, 5000);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
// 2000 pixels -> typical values for pictures
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
QTest::newRow("width: 2000px; height: 2000px;") << generateImageRgb888(2000, 2000);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
void tst_QImageConversion::convertRgb888ToRgb32()
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
{
QFETCH(QImage, inputImage);
QBENCHMARK {
SSSE3 optimized store of 24-bit formats Using shuffle and align storing our quint24 format can be done much faster. This in particular improves conversions to RGB888. Change-Id: I179748706a33a43fd6f60f5c40287317418c8867 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-02-26 15:53:24 +00:00
QImage output = inputImage.convertToFormat(QImage::Format_RGB32);
output.constBits();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
}
Optimize fallback RGB888 to RGB32 conversion Improves the conversion from RGB888 to RGB32 on platforms without SIMD versions. This includes the fallback used on non-neon ARM devices. Besides image conversion the routine is also used for decoding JPEG. On x86 this version is within 0.7x of the speed of the SSSE3 version. Change-Id: Id131994d7c3c4f879d89e80f9d6c435bb5535ed7 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-19 10:20:52 +00:00
void tst_QImageConversion::convertRgb888ToRgbx8888_data()
{
convertRgb888ToRgb32_data();
}
void tst_QImageConversion::convertRgb888ToRgbx8888()
{
QFETCH(QImage, inputImage);
QBENCHMARK {
SSSE3 optimized store of 24-bit formats Using shuffle and align storing our quint24 format can be done much faster. This in particular improves conversions to RGB888. Change-Id: I179748706a33a43fd6f60f5c40287317418c8867 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-02-26 15:53:24 +00:00
QImage output = inputImage.convertToFormat(QImage::Format_RGBX8888);
output.constBits();
Optimize fallback RGB888 to RGB32 conversion Improves the conversion from RGB888 to RGB32 on platforms without SIMD versions. This includes the fallback used on non-neon ARM devices. Besides image conversion the routine is also used for decoding JPEG. On x86 this version is within 0.7x of the speed of the SSSE3 version. Change-Id: Id131994d7c3c4f879d89e80f9d6c435bb5535ed7 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-19 10:20:52 +00:00
}
}
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
void tst_QImageConversion::convertRgb32ToRgb888_data()
{
QTest::addColumn<QImage>("inputImage");
// height = 5000 to get interesting timing.
// 3 pixels wide -> smaller than regular vector of 128bits
QTest::newRow("width: 3px; height: 5000px;") << generateImageRgb32(3, 5000);
// 8 pixels wide -> potential for 2 vectors
QTest::newRow("width: 8px; height: 5000px;") << generateImageRgb32(8, 5000);
// 16 pixels, minimum for the SSSE3 implementation
QTest::newRow("width: 16px; height: 5000px;") << generateImageRgb32(16, 5000);
// 50 pixels, more realistic use case
QTest::newRow("width: 50px; height: 5000px;") << generateImageRgb32(50, 5000);
// 2000 pixels -> typical values for pictures
QTest::newRow("width: 2000px; height: 2000px;") << generateImageRgb32(2000, 2000);
}
void tst_QImageConversion::convertRgb32ToRgb888()
{
QFETCH(QImage, inputImage);
QBENCHMARK {
SSSE3 optimized store of 24-bit formats Using shuffle and align storing our quint24 format can be done much faster. This in particular improves conversions to RGB888. Change-Id: I179748706a33a43fd6f60f5c40287317418c8867 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-02-26 15:53:24 +00:00
QImage output = inputImage.convertToFormat(QImage::Format_RGB888);
output.constBits();
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
}
}
Add missing RGB32 <-> RGB30 convertions Completes the inplace converters so that we can rely on inplace conversions to succede as long as the image depth is the same. Change-Id: Ia1ae34b5de1bc16e87ff5403bdacfcae44a22791 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-27 13:03:09 +00:00
void tst_QImageConversion::convertRgb16_data()
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
{
QTest::addColumn<QImage>("inputImage");
QTest::addColumn<QImage::Format>("outputFormat");
QImage rgb16 = generateImageRgb16(1000, 1000);
Add missing RGB32 <-> RGB30 convertions Completes the inplace converters so that we can rely on inplace conversions to succede as long as the image depth is the same. Change-Id: Ia1ae34b5de1bc16e87ff5403bdacfcae44a22791 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-27 13:03:09 +00:00
QTest::newRow("rgb32") << rgb16 << QImage::Format_RGB32;
QTest::newRow("rgb888") << rgb16 << QImage::Format_RGB888;
QTest::newRow("rgb666") << rgb16 << QImage::Format_RGB666;
QTest::newRow("rgb555") << rgb16 << QImage::Format_RGB555;
SSSE3 optimized store of 24-bit formats Using shuffle and align storing our quint24 format can be done much faster. This in particular improves conversions to RGB888. Change-Id: I179748706a33a43fd6f60f5c40287317418c8867 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-02-26 15:53:24 +00:00
QTest::newRow("argb8565") << rgb16 << QImage::Format_ARGB8565_Premultiplied;
QTest::newRow("argb8555") << rgb16 << QImage::Format_ARGB8555_Premultiplied;
Add missing RGB32 <-> RGB30 convertions Completes the inplace converters so that we can rely on inplace conversions to succede as long as the image depth is the same. Change-Id: Ia1ae34b5de1bc16e87ff5403bdacfcae44a22791 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-27 13:03:09 +00:00
}
void tst_QImageConversion::convertRgb16()
{
QFETCH(QImage, inputImage);
QFETCH(QImage::Format, outputFormat);
QBENCHMARK {
QImage output = inputImage.convertToFormat(outputFormat);
output.constBits();
}
}
void tst_QImageConversion::convertRgb32_data()
{
QTest::addColumn<QImage>("inputImage");
QTest::addColumn<QImage::Format>("outputFormat");
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
QImage rgb32 = generateImageRgb32(1000, 1000);
QImage argb32 = generateImageArgb32(1000, 1000);
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
QImage argb32pm = argb32.convertToFormat(QImage::Format_ARGB32_Premultiplied);
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
QTest::newRow("rgb32 -> rgb16") << rgb32 << QImage::Format_RGB16;
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
QTest::newRow("rgb32 -> argb32") << rgb32 << QImage::Format_ARGB32;
QTest::newRow("rgb32 -> argb32pm") << rgb32 << QImage::Format_ARGB32_Premultiplied;
QTest::newRow("rgb32 -> rgbx8888") << rgb32 << QImage::Format_RGBX8888;
QTest::newRow("rgb32 -> rgba8888") << rgb32 << QImage::Format_RGBA8888;
QTest::newRow("rgb32 -> rgba8888pm") << rgb32 << QImage::Format_RGBA8888_Premultiplied;
QTest::newRow("rgb32 -> rgb30") << rgb32 << QImage::Format_RGB30;
Add missing RGB32 <-> RGB30 convertions Completes the inplace converters so that we can rely on inplace conversions to succede as long as the image depth is the same. Change-Id: Ia1ae34b5de1bc16e87ff5403bdacfcae44a22791 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-27 13:03:09 +00:00
QTest::newRow("rgb32 -> a2bgr30") << rgb32 << QImage::Format_A2BGR30_Premultiplied;
QTest::newRow("rgb32 -> rgb888") << rgb32 << QImage::Format_RGB888;
QTest::newRow("rgb32 -> rgb666") << rgb32 << QImage::Format_RGB666;
QTest::newRow("rgb32 -> rgb555") << rgb32 << QImage::Format_RGB555;
SSSE3 optimized store of 24-bit formats Using shuffle and align storing our quint24 format can be done much faster. This in particular improves conversions to RGB888. Change-Id: I179748706a33a43fd6f60f5c40287317418c8867 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-02-26 15:53:24 +00:00
QTest::newRow("rgb32 -> argb8565pm") << rgb32 << QImage::Format_ARGB8565_Premultiplied;
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
Add missing RGB32 <-> RGB30 convertions Completes the inplace converters so that we can rely on inplace conversions to succede as long as the image depth is the same. Change-Id: Ia1ae34b5de1bc16e87ff5403bdacfcae44a22791 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-27 13:03:09 +00:00
QTest::newRow("argb32 -> rgb16") << argb32 << QImage::Format_RGB16;
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
QTest::newRow("argb32 -> rgb32") << argb32 << QImage::Format_RGB32;
Only use 32bit version of qPremultiply With auto-vectorization enabled in QtGui, the 32bit version of qPremultiply is faster than the 64bit version since it can be vectorized wider (4x on 128bit as opposed to 2x). Since all our important 64bit targets have SIMD, that makes the 64bit version pointless. Change-Id: I4e9070a3a3c8e2b54f17a95ba0aee0405cbb8ec9 Reviewed-by: Marc Mutz <marc.mutz@kdab.com>
2015-01-27 13:08:17 +00:00
QTest::newRow("argb32 -> argb32pm") << argb32 << QImage::Format_ARGB32_Premultiplied;
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
QTest::newRow("argb32 -> rgbx8888") << argb32 << QImage::Format_RGBX8888;
QTest::newRow("argb32 -> rgba8888") << argb32 << QImage::Format_RGBA8888;
Generate SSE4.1 versions of premultiplying methods where convenient The autovectorized versions of premultiplying conversions are almost twice as fast with SSE4.1 as with SSE2. Therefore this patch lets compilers that can make those versions convenient without duplicating code do that and lets us use them when available. Change-Id: I699035963abe55a38b9ef8ba7b4a8c961c8dfcdd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-01-28 10:07:14 +00:00
QTest::newRow("argb32 -> rgba8888pm") << argb32 << QImage::Format_RGBA8888_Premultiplied;
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
QTest::newRow("argb32 -> rgb30") << argb32 << QImage::Format_RGB30;
Add missing RGB32 <-> RGB30 convertions Completes the inplace converters so that we can rely on inplace conversions to succede as long as the image depth is the same. Change-Id: Ia1ae34b5de1bc16e87ff5403bdacfcae44a22791 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-27 13:03:09 +00:00
QTest::newRow("argb32 -> a2bgr30") << argb32 << QImage::Format_A2BGR30_Premultiplied;
QTest::newRow("argb32 -> rgb888") << argb32 << QImage::Format_RGB888;
QTest::newRow("argb32 -> rgb666") << argb32 << QImage::Format_RGB666;
QTest::newRow("argb32 -> argb8565pm") << argb32 << QImage::Format_ARGB8565_Premultiplied;
QTest::newRow("argb32 -> argb4444pm") << argb32 << QImage::Format_ARGB4444_Premultiplied;
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
Add missing RGB32 <-> RGB30 convertions Completes the inplace converters so that we can rely on inplace conversions to succede as long as the image depth is the same. Change-Id: Ia1ae34b5de1bc16e87ff5403bdacfcae44a22791 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-27 13:03:09 +00:00
QTest::newRow("argb32pm -> rgb16") << argb32pm << QImage::Format_RGB16;
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
QTest::newRow("argb32pm -> rgb32") << argb32pm << QImage::Format_RGB32;
QTest::newRow("argb32pm -> argb32") << argb32pm << QImage::Format_ARGB32;
QTest::newRow("argb32pm -> rgbx8888") << argb32pm << QImage::Format_RGBX8888;
QTest::newRow("argb32pm -> rgba8888") << argb32pm << QImage::Format_RGBA8888;
QTest::newRow("argb32pm -> rgba8888pm") << argb32pm << QImage::Format_RGBA8888_Premultiplied;
QTest::newRow("argb32pm -> rgb30") << argb32pm << QImage::Format_RGB30;
Add missing RGB32 <-> RGB30 convertions Completes the inplace converters so that we can rely on inplace conversions to succede as long as the image depth is the same. Change-Id: Ia1ae34b5de1bc16e87ff5403bdacfcae44a22791 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-27 13:03:09 +00:00
QTest::newRow("argb32pm -> a2bgr30") << argb32pm << QImage::Format_A2BGR30_Premultiplied;
QTest::newRow("argb32pm -> rgb888") << argb32pm << QImage::Format_RGB888;
QTest::newRow("argb32pm -> rgb666") << argb32pm << QImage::Format_RGB666;
QTest::newRow("argb32pm -> argb8565pm") << argb32pm << QImage::Format_ARGB8565_Premultiplied;
QTest::newRow("argb32pm -> argb4444pm") << argb32pm << QImage::Format_ARGB4444_Premultiplied;
}
void tst_QImageConversion::convertRgb32()
{
QFETCH(QImage, inputImage);
QFETCH(QImage::Format, outputFormat);
QBENCHMARK {
QImage output = inputImage.convertToFormat(outputFormat);
output.constBits();
}
}
void tst_QImageConversion::convertGeneric_data()
{
QTest::addColumn<QImage>("inputImage");
QTest::addColumn<QImage::Format>("outputFormat");
QImage rgb32 = generateImageRgb32(1000, 1000);
QImage argb32 = generateImageArgb32(1000, 1000);
QImage rgba32 = argb32.convertToFormat(QImage::Format_RGBA8888);
QImage bgr30 = rgb32.convertToFormat(QImage::Format_BGR30);
QImage a2rgb30 = argb32.convertToFormat(QImage::Format_A2RGB30_Premultiplied);
SSSE3 optimized store of 24-bit formats Using shuffle and align storing our quint24 format can be done much faster. This in particular improves conversions to RGB888. Change-Id: I179748706a33a43fd6f60f5c40287317418c8867 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-02-26 15:53:24 +00:00
QImage rgb666 = rgb32.convertToFormat(QImage::Format_RGB666);
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
QTest::newRow("rgba8888 -> rgb32") << rgba32 << QImage::Format_RGB32;
QTest::newRow("rgba8888 -> argb32") << rgba32 << QImage::Format_ARGB32;
QTest::newRow("rgba8888 -> argb32pm") << rgba32 << QImage::Format_ARGB32_Premultiplied;
QTest::newRow("rgba8888 -> rgbx8888") << rgba32 << QImage::Format_RGBX8888;
QTest::newRow("rgba8888 -> rgba8888pm") << rgba32 << QImage::Format_RGBA8888_Premultiplied;
SSSE3 optimized store of 24-bit formats Using shuffle and align storing our quint24 format can be done much faster. This in particular improves conversions to RGB888. Change-Id: I179748706a33a43fd6f60f5c40287317418c8867 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-02-26 15:53:24 +00:00
QTest::newRow("rgba8888 -> rgb888") << rgba32 << QImage::Format_RGB888;
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
QTest::newRow("rgba8888 -> rgb30") << rgba32 << QImage::Format_RGB30;
Add missing RGB32 <-> RGB30 convertions Completes the inplace converters so that we can rely on inplace conversions to succede as long as the image depth is the same. Change-Id: Ia1ae34b5de1bc16e87ff5403bdacfcae44a22791 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-27 13:03:09 +00:00
QTest::newRow("rgba8888 -> a2bgr30") << rgba32 << QImage::Format_A2BGR30_Premultiplied;
QTest::newRow("bgr30 -> rgb32") << bgr30 << QImage::Format_RGB32;
QTest::newRow("bgr30 -> argb32") << bgr30 << QImage::Format_ARGB32;
QTest::newRow("bgr30 -> argb32pm") << bgr30 << QImage::Format_ARGB32_Premultiplied;
QTest::newRow("bgr30 -> rgbx8888") << bgr30 << QImage::Format_RGBX8888;
QTest::newRow("bgr30 -> rgba8888") << bgr30 << QImage::Format_RGBA8888;
QTest::newRow("bgr30 -> rgba8888pm") << bgr30 << QImage::Format_RGBA8888_Premultiplied;
QTest::newRow("bgr30 -> rgb30") << bgr30 << QImage::Format_RGB30;
QTest::newRow("bgr30 -> a2bgr30") << bgr30 << QImage::Format_A2BGR30_Premultiplied;
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
QTest::newRow("a2rgb30 -> rgb32") << a2rgb30 << QImage::Format_RGB32;
QTest::newRow("a2rgb30 -> argb32") << a2rgb30 << QImage::Format_ARGB32;
QTest::newRow("a2rgb30 -> argb32pm") << a2rgb30 << QImage::Format_ARGB32_Premultiplied;
QTest::newRow("a2rgb30 -> rgbx8888") << a2rgb30 << QImage::Format_RGBX8888;
QTest::newRow("a2rgb30 -> rgba8888") << a2rgb30 << QImage::Format_RGBA8888;
QTest::newRow("a2rgb30 -> rgba8888pm") << a2rgb30 << QImage::Format_RGBA8888_Premultiplied;
Add missing RGB32 <-> RGB30 convertions Completes the inplace converters so that we can rely on inplace conversions to succede as long as the image depth is the same. Change-Id: Ia1ae34b5de1bc16e87ff5403bdacfcae44a22791 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-27 13:03:09 +00:00
QTest::newRow("a2rgb30 -> rgb30") << a2rgb30 << QImage::Format_RGB30;
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
QTest::newRow("a2rgb30 -> bgr30") << a2rgb30 << QImage::Format_BGR30;
Add missing RGB32 <-> RGB30 convertions Completes the inplace converters so that we can rely on inplace conversions to succede as long as the image depth is the same. Change-Id: Ia1ae34b5de1bc16e87ff5403bdacfcae44a22791 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-27 13:03:09 +00:00
QTest::newRow("a2rgb30 -> a2bgr30") << a2rgb30 << QImage::Format_A2BGR30_Premultiplied;
SSSE3 optimized store of 24-bit formats Using shuffle and align storing our quint24 format can be done much faster. This in particular improves conversions to RGB888. Change-Id: I179748706a33a43fd6f60f5c40287317418c8867 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-02-26 15:53:24 +00:00
QTest::newRow("rgb666 -> rgb32") << rgb666 << QImage::Format_RGB32;
QTest::newRow("rgb666 -> argb32") << rgb666 << QImage::Format_ARGB32;
QTest::newRow("rgb666 -> argb32pm") << rgb666 << QImage::Format_ARGB32_Premultiplied;
QTest::newRow("rgb666 -> rgb888") << rgb666 << QImage::Format_RGB888;
QTest::newRow("rgb666 -> rgb16") << rgb666 << QImage::Format_RGB16;
QTest::newRow("rgb666 -> rgb555") << rgb666 << QImage::Format_RGB555;
QTest::newRow("rgb666 -> rgb30") << rgb666 << QImage::Format_RGB30;
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
}
void tst_QImageConversion::convertGeneric()
{
QFETCH(QImage, inputImage);
QFETCH(QImage::Format, outputFormat);
QBENCHMARK {
QImage output = inputImage.convertToFormat(outputFormat);
output.constBits();
}
}
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
void tst_QImageConversion::convertGenericInplace_data()
{
QTest::addColumn<QImage>("inputImage");
QTest::addColumn<QImage::Format>("outputFormat");
QImage argb32 = generateImageArgb32(1000, 1000);
QImage argb32pm = argb32.convertToFormat(QImage::Format_ARGB32_Premultiplied);
QImage rgba8888 = argb32.convertToFormat(QImage::Format_RGBA8888);
SSSE3 optimized store of 24-bit formats Using shuffle and align storing our quint24 format can be done much faster. This in particular improves conversions to RGB888. Change-Id: I179748706a33a43fd6f60f5c40287317418c8867 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-02-26 15:53:24 +00:00
QImage argb6666 = argb32.convertToFormat(QImage::Format_ARGB6666_Premultiplied);
QImage argb4444 = argb32.convertToFormat(QImage::Format_ARGB4444_Premultiplied);
QImage rgb16 = argb32.convertToFormat(QImage::Format_RGB16);
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
QTest::newRow("argb32 -> argb32pm -> argb32") << argb32 << QImage::Format_ARGB32_Premultiplied;
QTest::newRow("argb32 -> rgb32 -> argb32") << argb32 << QImage::Format_RGB32;
QTest::newRow("argb32 -> rgba8888 -> argb32") << argb32 << QImage::Format_RGBA8888;
QTest::newRow("argb32 -> rgba8888pm -> argb32") << argb32 << QImage::Format_RGBA8888_Premultiplied;
QTest::newRow("argb32pm -> argb32 -> argb32pm") << argb32pm << QImage::Format_ARGB32;
QTest::newRow("argb32pm -> rgb32 -> argb32pm") << argb32pm << QImage::Format_RGB32;
QTest::newRow("argb32pm -> rgba8888pm -> argb32pm") << argb32pm << QImage::Format_RGBA8888_Premultiplied;
QTest::newRow("argb32pm -> rgba8888 -> argb32pm") << argb32pm << QImage::Format_RGBA8888;
QTest::newRow("argb32pm -> rgbx8888 -> argb32pm") << argb32pm << QImage::Format_RGBX8888;
QTest::newRow("rgba8888 -> argb32 -> rgba8888") << rgba8888 << QImage::Format_ARGB32;
QTest::newRow("rgba8888 -> rgb32 -> rgba8888") << rgba8888 << QImage::Format_RGB32;
QTest::newRow("rgba8888 -> argb32pm -> rgba8888") << rgba8888 << QImage::Format_ARGB32_Premultiplied;
QTest::newRow("rgba8888 -> rgba8888pm -> rgba8888") << rgba8888 << QImage::Format_RGBA8888_Premultiplied;
SSSE3 optimized store of 24-bit formats Using shuffle and align storing our quint24 format can be done much faster. This in particular improves conversions to RGB888. Change-Id: I179748706a33a43fd6f60f5c40287317418c8867 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-02-26 15:53:24 +00:00
QTest::newRow("argb6666pm -> argb8565pm -> argb6666pm") << argb6666 << QImage::Format_ARGB8565_Premultiplied;
QTest::newRow("argb6666pm -> rgb888 -> argb6666pm") << argb6666 << QImage::Format_RGB888;
QTest::newRow("argb4444pm -> rgb16 -> argb4444pm") << argb4444 << QImage::Format_RGB16;
QTest::newRow("argb4444pm -> rgb444 -> argb4444pm") << argb4444 << QImage::Format_RGB444;
QTest::newRow("rgb16 -> rgb555 -> rgb16") << rgb16 << QImage::Format_RGB555;
QTest::newRow("rgb16 -> rgb444 -> rgb16") << rgb16 << QImage::Format_RGB444;
QTest::newRow("rgb16 -> argb4444pm -> rgb16") << rgb16 << QImage::Format_ARGB4444_Premultiplied;
Optimize generic conversion and remove now obsolete direct conversions There are many direct QImage conversions that doesn't need to be direct but only are because they are faster than the generic conversion. This patch optimizes the generic conversions and then removes all the direct conversions that are now no faster than the generic. Change-Id: I3dc5f44cc7f6358fd66420e9974eebaf2c7ca59c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-05 15:09:00 +00:00
}
void tst_QImageConversion::convertGenericInplace()
{
QFETCH(QImage, inputImage);
QFETCH(QImage::Format, outputFormat);
QImage::Format inputFormat = inputImage.format();
QImage tmpImage = qMove(inputImage);
QBENCHMARK {
tmpImage = (qMove(tmpImage).convertToFormat(outputFormat)).convertToFormat(inputFormat);
}
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
/*
Fill a RGB888 image with "random" pixel values.
*/
QImage tst_QImageConversion::generateImageRgb888(int width, int height)
{
QImage image(width, height, QImage::Format_RGB888);
const int byteWidth = width * 3;
for (int y = 0; y < image.height(); ++y) {
uchar *scanline = image.scanLine(y);
for (int x = 0; x < byteWidth; ++x)
scanline[x] = x ^ y;
}
return image;
}
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
/*
Fill a RGB16 image with "random" pixel values.
*/
QImage tst_QImageConversion::generateImageRgb16(int width, int height)
{
QImage image(width, height, QImage::Format_RGB16);
const int byteWidth = width * 2;
for (int y = 0; y < image.height(); ++y) {
uchar *scanline = image.scanLine(y);
for (int x = 0; x < byteWidth; ++x)
scanline[x] = x ^ y;
}
return image;
}
/*
Fill a RGB32 image with "random" pixel values.
*/
QImage tst_QImageConversion::generateImageRgb32(int width, int height)
{
QImage image(width, height, QImage::Format_RGB32);
for (int y = 0; y < image.height(); ++y) {
QRgb *scanline = (QRgb*)image.scanLine(y);
for (int x = 0; x < width; ++x)
scanline[x] = qRgb(x, y, x ^ y);
}
return image;
}
/*
Fill a ARGB32 image with "random" pixel values.
*/
QImage tst_QImageConversion::generateImageArgb32(int width, int height)
{
QImage image(width, height, QImage::Format_ARGB32);
for (int y = 0; y < image.height(); ++y) {
Add missing RGB32 <-> RGB30 convertions Completes the inplace converters so that we can rely on inplace conversions to succede as long as the image depth is the same. Change-Id: Ia1ae34b5de1bc16e87ff5403bdacfcae44a22791 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-27 13:03:09 +00:00
QRgb *scanline = (QRgb*)image.scanLine(y);
for (int x = 0; x < width; ++x) {
int alpha = (x ^ y) & 0x1ff;
alpha = qMax(0, qMin(alpha - 128, 255));
scanline[x] = qRgba(x, y, x ^ y, alpha);
}
Optimize drawing to and from generic formats When drawing to and from the less common formats most of the cpu time is spend in conversion. The conversion method is rather slow due to using variable shifts and masks that the compiler does not have a chance to optimize. This patch changes the conversion methods to being templates fed by constexpr methods. This allows the compiler to fully optimize the methods yielding 2x->5x speedups. The reliance on constexpr however means the optimized methods are only used under C++11. Change-Id: I2ec77c4c1c03f12ee463a694a2b59db0f0b52db1 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 11:20:21 +00:00
}
return image;
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QTEST_MAIN(tst_QImageConversion)
#include "tst_qimageconversion.moc"
Reference in New Issue Copy Permalink