diff options
Diffstat (limited to 'src/gui/painting/qpixellayout.cpp')
| -rw-r--r-- | src/gui/painting/qpixellayout.cpp | 1587 |
1 files changed, 1239 insertions, 348 deletions
diff --git a/src/gui/painting/qpixellayout.cpp b/src/gui/painting/qpixellayout.cpp index 42d14bb3b3..4f2f0ae13a 100644 --- a/src/gui/painting/qpixellayout.cpp +++ b/src/gui/painting/qpixellayout.cpp @@ -1,41 +1,5 @@ -/**************************************************************************** -** -** Copyright (C) 2020 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the QtGui module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** 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 -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** 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-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// Copyright (C) 2021 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only #include <qglobal.h> @@ -43,152 +7,180 @@ #include "qpixellayout_p.h" #include "qrgba64_p.h" #include <QtCore/private/qsimd_p.h> +#include <QtGui/private/qcmyk_p.h> QT_BEGIN_NAMESPACE -template<QImage::Format> Q_DECL_CONSTEXPR uint redWidth(); -template<QImage::Format> Q_DECL_CONSTEXPR uint redShift(); -template<QImage::Format> Q_DECL_CONSTEXPR uint greenWidth(); -template<QImage::Format> Q_DECL_CONSTEXPR uint greenShift(); -template<QImage::Format> Q_DECL_CONSTEXPR uint blueWidth(); -template<QImage::Format> Q_DECL_CONSTEXPR uint blueShift(); -template<QImage::Format> Q_DECL_CONSTEXPR uint alphaWidth(); -template<QImage::Format> Q_DECL_CONSTEXPR uint alphaShift(); - -template<> Q_DECL_CONSTEXPR uint redWidth<QImage::Format_RGB16>() { return 5; } -template<> Q_DECL_CONSTEXPR uint redWidth<QImage::Format_RGB444>() { return 4; } -template<> Q_DECL_CONSTEXPR uint redWidth<QImage::Format_RGB555>() { return 5; } -template<> Q_DECL_CONSTEXPR uint redWidth<QImage::Format_RGB666>() { return 6; } -template<> Q_DECL_CONSTEXPR uint redWidth<QImage::Format_RGB888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint redWidth<QImage::Format_BGR888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint redWidth<QImage::Format_ARGB4444_Premultiplied>() { return 4; } -template<> Q_DECL_CONSTEXPR uint redWidth<QImage::Format_ARGB8555_Premultiplied>() { return 5; } -template<> Q_DECL_CONSTEXPR uint redWidth<QImage::Format_ARGB8565_Premultiplied>() { return 5; } -template<> Q_DECL_CONSTEXPR uint redWidth<QImage::Format_ARGB6666_Premultiplied>() { return 6; } -template<> Q_DECL_CONSTEXPR uint redWidth<QImage::Format_RGBX8888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint redWidth<QImage::Format_RGBA8888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint redWidth<QImage::Format_RGBA8888_Premultiplied>() { return 8; } - -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_RGB16>() { return 11; } -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_RGB444>() { return 8; } -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_RGB555>() { return 10; } -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_RGB666>() { return 12; } -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_RGB888>() { return 16; } -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_BGR888>() { return 0; } -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_ARGB4444_Premultiplied>() { return 8; } -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_ARGB8555_Premultiplied>() { return 18; } -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_ARGB8565_Premultiplied>() { return 19; } -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_ARGB6666_Premultiplied>() { return 12; } +template<QImage::Format> constexpr uint redWidth(); +template<QImage::Format> constexpr uint redShift(); +template<QImage::Format> constexpr uint greenWidth(); +template<QImage::Format> constexpr uint greenShift(); +template<QImage::Format> constexpr uint blueWidth(); +template<QImage::Format> constexpr uint blueShift(); +template<QImage::Format> constexpr uint alphaWidth(); +template<QImage::Format> constexpr uint alphaShift(); + +template<> constexpr uint redWidth<QImage::Format_RGB32>() { return 8; } +template<> constexpr uint redWidth<QImage::Format_ARGB32>() { return 8; } +template<> constexpr uint redWidth<QImage::Format_ARGB32_Premultiplied>() { return 8; } +template<> constexpr uint redWidth<QImage::Format_RGB16>() { return 5; } +template<> constexpr uint redWidth<QImage::Format_RGB444>() { return 4; } +template<> constexpr uint redWidth<QImage::Format_RGB555>() { return 5; } +template<> constexpr uint redWidth<QImage::Format_RGB666>() { return 6; } +template<> constexpr uint redWidth<QImage::Format_RGB888>() { return 8; } +template<> constexpr uint redWidth<QImage::Format_BGR888>() { return 8; } +template<> constexpr uint redWidth<QImage::Format_ARGB4444_Premultiplied>() { return 4; } +template<> constexpr uint redWidth<QImage::Format_ARGB8555_Premultiplied>() { return 5; } +template<> constexpr uint redWidth<QImage::Format_ARGB8565_Premultiplied>() { return 5; } +template<> constexpr uint redWidth<QImage::Format_ARGB6666_Premultiplied>() { return 6; } +template<> constexpr uint redWidth<QImage::Format_RGBX8888>() { return 8; } +template<> constexpr uint redWidth<QImage::Format_RGBA8888>() { return 8; } +template<> constexpr uint redWidth<QImage::Format_RGBA8888_Premultiplied>() { return 8; } + +template<> constexpr uint redShift<QImage::Format_RGB32>() { return 16; } +template<> constexpr uint redShift<QImage::Format_ARGB32>() { return 16; } +template<> constexpr uint redShift<QImage::Format_ARGB32_Premultiplied>() { return 16; } +template<> constexpr uint redShift<QImage::Format_RGB16>() { return 11; } +template<> constexpr uint redShift<QImage::Format_RGB444>() { return 8; } +template<> constexpr uint redShift<QImage::Format_RGB555>() { return 10; } +template<> constexpr uint redShift<QImage::Format_RGB666>() { return 12; } +template<> constexpr uint redShift<QImage::Format_RGB888>() { return 16; } +template<> constexpr uint redShift<QImage::Format_BGR888>() { return 0; } +template<> constexpr uint redShift<QImage::Format_ARGB4444_Premultiplied>() { return 8; } +template<> constexpr uint redShift<QImage::Format_ARGB8555_Premultiplied>() { return 18; } +template<> constexpr uint redShift<QImage::Format_ARGB8565_Premultiplied>() { return 19; } +template<> constexpr uint redShift<QImage::Format_ARGB6666_Premultiplied>() { return 12; } #if Q_BYTE_ORDER == Q_BIG_ENDIAN -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_RGBX8888>() { return 24; } -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_RGBA8888>() { return 24; } -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_RGBA8888_Premultiplied>() { return 24; } +template<> constexpr uint redShift<QImage::Format_RGBX8888>() { return 24; } +template<> constexpr uint redShift<QImage::Format_RGBA8888>() { return 24; } +template<> constexpr uint redShift<QImage::Format_RGBA8888_Premultiplied>() { return 24; } #else -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_RGBX8888>() { return 0; } -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_RGBA8888>() { return 0; } -template<> Q_DECL_CONSTEXPR uint redShift<QImage::Format_RGBA8888_Premultiplied>() { return 0; } +template<> constexpr uint redShift<QImage::Format_RGBX8888>() { return 0; } +template<> constexpr uint redShift<QImage::Format_RGBA8888>() { return 0; } +template<> constexpr uint redShift<QImage::Format_RGBA8888_Premultiplied>() { return 0; } #endif -template<> Q_DECL_CONSTEXPR uint greenWidth<QImage::Format_RGB16>() { return 6; } -template<> Q_DECL_CONSTEXPR uint greenWidth<QImage::Format_RGB444>() { return 4; } -template<> Q_DECL_CONSTEXPR uint greenWidth<QImage::Format_RGB555>() { return 5; } -template<> Q_DECL_CONSTEXPR uint greenWidth<QImage::Format_RGB666>() { return 6; } -template<> Q_DECL_CONSTEXPR uint greenWidth<QImage::Format_RGB888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint greenWidth<QImage::Format_BGR888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint greenWidth<QImage::Format_ARGB4444_Premultiplied>() { return 4; } -template<> Q_DECL_CONSTEXPR uint greenWidth<QImage::Format_ARGB8555_Premultiplied>() { return 5; } -template<> Q_DECL_CONSTEXPR uint greenWidth<QImage::Format_ARGB8565_Premultiplied>() { return 6; } -template<> Q_DECL_CONSTEXPR uint greenWidth<QImage::Format_ARGB6666_Premultiplied>() { return 6; } -template<> Q_DECL_CONSTEXPR uint greenWidth<QImage::Format_RGBX8888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint greenWidth<QImage::Format_RGBA8888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint greenWidth<QImage::Format_RGBA8888_Premultiplied>() { return 8; } - -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_RGB16>() { return 5; } -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_RGB444>() { return 4; } -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_RGB555>() { return 5; } -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_RGB666>() { return 6; } -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_RGB888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_BGR888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_ARGB4444_Premultiplied>() { return 4; } -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_ARGB8555_Premultiplied>() { return 13; } -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_ARGB8565_Premultiplied>() { return 13; } -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_ARGB6666_Premultiplied>() { return 6; } +template<> constexpr uint greenWidth<QImage::Format_RGB32>() { return 8; } +template<> constexpr uint greenWidth<QImage::Format_ARGB32>() { return 8; } +template<> constexpr uint greenWidth<QImage::Format_ARGB32_Premultiplied>() { return 8; } +template<> constexpr uint greenWidth<QImage::Format_RGB16>() { return 6; } +template<> constexpr uint greenWidth<QImage::Format_RGB444>() { return 4; } +template<> constexpr uint greenWidth<QImage::Format_RGB555>() { return 5; } +template<> constexpr uint greenWidth<QImage::Format_RGB666>() { return 6; } +template<> constexpr uint greenWidth<QImage::Format_RGB888>() { return 8; } +template<> constexpr uint greenWidth<QImage::Format_BGR888>() { return 8; } +template<> constexpr uint greenWidth<QImage::Format_ARGB4444_Premultiplied>() { return 4; } +template<> constexpr uint greenWidth<QImage::Format_ARGB8555_Premultiplied>() { return 5; } +template<> constexpr uint greenWidth<QImage::Format_ARGB8565_Premultiplied>() { return 6; } +template<> constexpr uint greenWidth<QImage::Format_ARGB6666_Premultiplied>() { return 6; } +template<> constexpr uint greenWidth<QImage::Format_RGBX8888>() { return 8; } +template<> constexpr uint greenWidth<QImage::Format_RGBA8888>() { return 8; } +template<> constexpr uint greenWidth<QImage::Format_RGBA8888_Premultiplied>() { return 8; } + +template<> constexpr uint greenShift<QImage::Format_RGB32>() { return 8; } +template<> constexpr uint greenShift<QImage::Format_ARGB32>() { return 8; } +template<> constexpr uint greenShift<QImage::Format_ARGB32_Premultiplied>() { return 8; } +template<> constexpr uint greenShift<QImage::Format_RGB16>() { return 5; } +template<> constexpr uint greenShift<QImage::Format_RGB444>() { return 4; } +template<> constexpr uint greenShift<QImage::Format_RGB555>() { return 5; } +template<> constexpr uint greenShift<QImage::Format_RGB666>() { return 6; } +template<> constexpr uint greenShift<QImage::Format_RGB888>() { return 8; } +template<> constexpr uint greenShift<QImage::Format_BGR888>() { return 8; } +template<> constexpr uint greenShift<QImage::Format_ARGB4444_Premultiplied>() { return 4; } +template<> constexpr uint greenShift<QImage::Format_ARGB8555_Premultiplied>() { return 13; } +template<> constexpr uint greenShift<QImage::Format_ARGB8565_Premultiplied>() { return 13; } +template<> constexpr uint greenShift<QImage::Format_ARGB6666_Premultiplied>() { return 6; } #if Q_BYTE_ORDER == Q_BIG_ENDIAN -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_RGBX8888>() { return 16; } -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_RGBA8888>() { return 16; } -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_RGBA8888_Premultiplied>() { return 16; } +template<> constexpr uint greenShift<QImage::Format_RGBX8888>() { return 16; } +template<> constexpr uint greenShift<QImage::Format_RGBA8888>() { return 16; } +template<> constexpr uint greenShift<QImage::Format_RGBA8888_Premultiplied>() { return 16; } #else -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_RGBX8888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_RGBA8888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint greenShift<QImage::Format_RGBA8888_Premultiplied>() { return 8; } +template<> constexpr uint greenShift<QImage::Format_RGBX8888>() { return 8; } +template<> constexpr uint greenShift<QImage::Format_RGBA8888>() { return 8; } +template<> constexpr uint greenShift<QImage::Format_RGBA8888_Premultiplied>() { return 8; } #endif -template<> Q_DECL_CONSTEXPR uint blueWidth<QImage::Format_RGB16>() { return 5; } -template<> Q_DECL_CONSTEXPR uint blueWidth<QImage::Format_RGB444>() { return 4; } -template<> Q_DECL_CONSTEXPR uint blueWidth<QImage::Format_RGB555>() { return 5; } -template<> Q_DECL_CONSTEXPR uint blueWidth<QImage::Format_RGB666>() { return 6; } -template<> Q_DECL_CONSTEXPR uint blueWidth<QImage::Format_RGB888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint blueWidth<QImage::Format_BGR888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint blueWidth<QImage::Format_ARGB4444_Premultiplied>() { return 4; } -template<> Q_DECL_CONSTEXPR uint blueWidth<QImage::Format_ARGB8555_Premultiplied>() { return 5; } -template<> Q_DECL_CONSTEXPR uint blueWidth<QImage::Format_ARGB8565_Premultiplied>() { return 5; } -template<> Q_DECL_CONSTEXPR uint blueWidth<QImage::Format_ARGB6666_Premultiplied>() { return 6; } -template<> Q_DECL_CONSTEXPR uint blueWidth<QImage::Format_RGBX8888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint blueWidth<QImage::Format_RGBA8888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint blueWidth<QImage::Format_RGBA8888_Premultiplied>() { return 8; } - -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_RGB16>() { return 0; } -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_RGB444>() { return 0; } -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_RGB555>() { return 0; } -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_RGB666>() { return 0; } -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_RGB888>() { return 0; } -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_BGR888>() { return 16; } -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_ARGB4444_Premultiplied>() { return 0; } -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_ARGB8555_Premultiplied>() { return 8; } -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_ARGB8565_Premultiplied>() { return 8; } -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_ARGB6666_Premultiplied>() { return 0; } +template<> constexpr uint blueWidth<QImage::Format_RGB32>() { return 8; } +template<> constexpr uint blueWidth<QImage::Format_ARGB32>() { return 8; } +template<> constexpr uint blueWidth<QImage::Format_ARGB32_Premultiplied>() { return 8; } +template<> constexpr uint blueWidth<QImage::Format_RGB16>() { return 5; } +template<> constexpr uint blueWidth<QImage::Format_RGB444>() { return 4; } +template<> constexpr uint blueWidth<QImage::Format_RGB555>() { return 5; } +template<> constexpr uint blueWidth<QImage::Format_RGB666>() { return 6; } +template<> constexpr uint blueWidth<QImage::Format_RGB888>() { return 8; } +template<> constexpr uint blueWidth<QImage::Format_BGR888>() { return 8; } +template<> constexpr uint blueWidth<QImage::Format_ARGB4444_Premultiplied>() { return 4; } +template<> constexpr uint blueWidth<QImage::Format_ARGB8555_Premultiplied>() { return 5; } +template<> constexpr uint blueWidth<QImage::Format_ARGB8565_Premultiplied>() { return 5; } +template<> constexpr uint blueWidth<QImage::Format_ARGB6666_Premultiplied>() { return 6; } +template<> constexpr uint blueWidth<QImage::Format_RGBX8888>() { return 8; } +template<> constexpr uint blueWidth<QImage::Format_RGBA8888>() { return 8; } +template<> constexpr uint blueWidth<QImage::Format_RGBA8888_Premultiplied>() { return 8; } + +template<> constexpr uint blueShift<QImage::Format_RGB32>() { return 0; } +template<> constexpr uint blueShift<QImage::Format_ARGB32>() { return 0; } +template<> constexpr uint blueShift<QImage::Format_ARGB32_Premultiplied>() { return 0; } +template<> constexpr uint blueShift<QImage::Format_RGB16>() { return 0; } +template<> constexpr uint blueShift<QImage::Format_RGB444>() { return 0; } +template<> constexpr uint blueShift<QImage::Format_RGB555>() { return 0; } +template<> constexpr uint blueShift<QImage::Format_RGB666>() { return 0; } +template<> constexpr uint blueShift<QImage::Format_RGB888>() { return 0; } +template<> constexpr uint blueShift<QImage::Format_BGR888>() { return 16; } +template<> constexpr uint blueShift<QImage::Format_ARGB4444_Premultiplied>() { return 0; } +template<> constexpr uint blueShift<QImage::Format_ARGB8555_Premultiplied>() { return 8; } +template<> constexpr uint blueShift<QImage::Format_ARGB8565_Premultiplied>() { return 8; } +template<> constexpr uint blueShift<QImage::Format_ARGB6666_Premultiplied>() { return 0; } #if Q_BYTE_ORDER == Q_BIG_ENDIAN -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_RGBX8888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_RGBA8888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_RGBA8888_Premultiplied>() { return 8; } +template<> constexpr uint blueShift<QImage::Format_RGBX8888>() { return 8; } +template<> constexpr uint blueShift<QImage::Format_RGBA8888>() { return 8; } +template<> constexpr uint blueShift<QImage::Format_RGBA8888_Premultiplied>() { return 8; } #else -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_RGBX8888>() { return 16; } -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_RGBA8888>() { return 16; } -template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_RGBA8888_Premultiplied>() { return 16; } +template<> constexpr uint blueShift<QImage::Format_RGBX8888>() { return 16; } +template<> constexpr uint blueShift<QImage::Format_RGBA8888>() { return 16; } +template<> constexpr uint blueShift<QImage::Format_RGBA8888_Premultiplied>() { return 16; } #endif -template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_RGB16>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_RGB444>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_RGB555>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_RGB666>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_RGB888>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_BGR888>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_ARGB4444_Premultiplied>() { return 4; } -template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_ARGB8555_Premultiplied>() { return 8; } -template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_ARGB8565_Premultiplied>() { return 8; } -template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_ARGB6666_Premultiplied>() { return 6; } -template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_RGBX8888>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_RGBA8888>() { return 8; } -template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_RGBA8888_Premultiplied>() { return 8; } - -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGB16>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGB444>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGB555>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGB666>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGB888>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_BGR888>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_ARGB4444_Premultiplied>() { return 12; } -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_ARGB8555_Premultiplied>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_ARGB8565_Premultiplied>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_ARGB6666_Premultiplied>() { return 18; } +template<> constexpr uint alphaWidth<QImage::Format_RGB32>() { return 0; } +template<> constexpr uint alphaWidth<QImage::Format_ARGB32>() { return 8; } +template<> constexpr uint alphaWidth<QImage::Format_ARGB32_Premultiplied>() { return 8; } +template<> constexpr uint alphaWidth<QImage::Format_RGB16>() { return 0; } +template<> constexpr uint alphaWidth<QImage::Format_RGB444>() { return 0; } +template<> constexpr uint alphaWidth<QImage::Format_RGB555>() { return 0; } +template<> constexpr uint alphaWidth<QImage::Format_RGB666>() { return 0; } +template<> constexpr uint alphaWidth<QImage::Format_RGB888>() { return 0; } +template<> constexpr uint alphaWidth<QImage::Format_BGR888>() { return 0; } +template<> constexpr uint alphaWidth<QImage::Format_ARGB4444_Premultiplied>() { return 4; } +template<> constexpr uint alphaWidth<QImage::Format_ARGB8555_Premultiplied>() { return 8; } +template<> constexpr uint alphaWidth<QImage::Format_ARGB8565_Premultiplied>() { return 8; } +template<> constexpr uint alphaWidth<QImage::Format_ARGB6666_Premultiplied>() { return 6; } +template<> constexpr uint alphaWidth<QImage::Format_RGBX8888>() { return 0; } +template<> constexpr uint alphaWidth<QImage::Format_RGBA8888>() { return 8; } +template<> constexpr uint alphaWidth<QImage::Format_RGBA8888_Premultiplied>() { return 8; } + +template<> constexpr uint alphaShift<QImage::Format_RGB32>() { return 24; } +template<> constexpr uint alphaShift<QImage::Format_ARGB32>() { return 24; } +template<> constexpr uint alphaShift<QImage::Format_ARGB32_Premultiplied>() { return 24; } +template<> constexpr uint alphaShift<QImage::Format_RGB16>() { return 0; } +template<> constexpr uint alphaShift<QImage::Format_RGB444>() { return 0; } +template<> constexpr uint alphaShift<QImage::Format_RGB555>() { return 0; } +template<> constexpr uint alphaShift<QImage::Format_RGB666>() { return 0; } +template<> constexpr uint alphaShift<QImage::Format_RGB888>() { return 0; } +template<> constexpr uint alphaShift<QImage::Format_BGR888>() { return 0; } +template<> constexpr uint alphaShift<QImage::Format_ARGB4444_Premultiplied>() { return 12; } +template<> constexpr uint alphaShift<QImage::Format_ARGB8555_Premultiplied>() { return 0; } +template<> constexpr uint alphaShift<QImage::Format_ARGB8565_Premultiplied>() { return 0; } +template<> constexpr uint alphaShift<QImage::Format_ARGB6666_Premultiplied>() { return 18; } #if Q_BYTE_ORDER == Q_BIG_ENDIAN -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGBX8888>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGBA8888>() { return 0; } -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGBA8888_Premultiplied>() { return 0; } +template<> constexpr uint alphaShift<QImage::Format_RGBX8888>() { return 0; } +template<> constexpr uint alphaShift<QImage::Format_RGBA8888>() { return 0; } +template<> constexpr uint alphaShift<QImage::Format_RGBA8888_Premultiplied>() { return 0; } #else -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGBX8888>() { return 24; } -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGBA8888>() { return 24; } -template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGBA8888_Premultiplied>() { return 24; } +template<> constexpr uint alphaShift<QImage::Format_RGBX8888>() { return 24; } +template<> constexpr uint alphaShift<QImage::Format_RGBA8888>() { return 24; } +template<> constexpr uint alphaShift<QImage::Format_RGBA8888_Premultiplied>() { return 24; } #endif template<QImage::Format> constexpr QPixelLayout::BPP bitsPerPixel(); +template<> constexpr QPixelLayout::BPP bitsPerPixel<QImage::Format_RGB32>() { return QPixelLayout::BPP32; } +template<> constexpr QPixelLayout::BPP bitsPerPixel<QImage::Format_ARGB32>() { return QPixelLayout::BPP32; } +template<> constexpr QPixelLayout::BPP bitsPerPixel<QImage::Format_ARGB32_Premultiplied>() { return QPixelLayout::BPP32; } template<> constexpr QPixelLayout::BPP bitsPerPixel<QImage::Format_RGB16>() { return QPixelLayout::BPP16; } template<> constexpr QPixelLayout::BPP bitsPerPixel<QImage::Format_RGB444>() { return QPixelLayout::BPP16; } template<> constexpr QPixelLayout::BPP bitsPerPixel<QImage::Format_RGB555>() { return QPixelLayout::BPP16; } @@ -218,20 +210,89 @@ inline void QT_FASTCALL storePixel<QPixelLayout::BPP24>(uchar *dest, int index, reinterpret_cast<quint24 *>(dest)[index] = quint24(pixel); } +template <QPixelLayout::BPP bpp> static +inline uint QT_FASTCALL fetchPixel(const uchar *, int) +{ + Q_UNREACHABLE_RETURN(0); +} + +template <> +inline uint QT_FASTCALL fetchPixel<QPixelLayout::BPP1LSB>(const uchar *src, int index) +{ + return (src[index >> 3] >> (index & 7)) & 1; +} + +template <> +inline uint QT_FASTCALL fetchPixel<QPixelLayout::BPP1MSB>(const uchar *src, int index) +{ + return (src[index >> 3] >> (~index & 7)) & 1; +} + +template <> +inline uint QT_FASTCALL fetchPixel<QPixelLayout::BPP8>(const uchar *src, int index) +{ + return src[index]; +} + +template <> +inline uint QT_FASTCALL fetchPixel<QPixelLayout::BPP16>(const uchar *src, int index) +{ + return reinterpret_cast<const quint16 *>(src)[index]; +} + +template <> +inline uint QT_FASTCALL fetchPixel<QPixelLayout::BPP24>(const uchar *src, int index) +{ + return reinterpret_cast<const quint24 *>(src)[index]; +} + +template <> +inline uint QT_FASTCALL fetchPixel<QPixelLayout::BPP32>(const uchar *src, int index) +{ + return reinterpret_cast<const uint *>(src)[index]; +} + +template <> +[[maybe_unused]] +inline uint QT_FASTCALL fetchPixel<QPixelLayout::BPP64>(const uchar *src, int index) +{ + // We have to do the conversion in fetch to fit into a 32bit uint + QRgba64 c = reinterpret_cast<const QRgba64 *>(src)[index]; + return c.toArgb32(); +} + +template <> +[[maybe_unused]] +inline uint QT_FASTCALL fetchPixel<QPixelLayout::BPP16FPx4>(const uchar *src, int index) +{ + // We have to do the conversion in fetch to fit into a 32bit uint + QRgbaFloat16 c = reinterpret_cast<const QRgbaFloat16 *>(src)[index]; + return c.toArgb32(); +} + +template <> +[[maybe_unused]] +inline uint QT_FASTCALL fetchPixel<QPixelLayout::BPP32FPx4>(const uchar *src, int index) +{ + // We have to do the conversion in fetch to fit into a 32bit uint + QRgbaFloat32 c = reinterpret_cast<const QRgbaFloat32 *>(src)[index]; + return c.toArgb32(); +} + template<QImage::Format Format> -static Q_ALWAYS_INLINE uint convertPixelToRGB32(uint s) +static inline uint convertPixelToRGB32(uint s) { - Q_CONSTEXPR uint redMask = ((1 << redWidth<Format>()) - 1); - Q_CONSTEXPR uint greenMask = ((1 << greenWidth<Format>()) - 1); - Q_CONSTEXPR uint blueMask = ((1 << blueWidth<Format>()) - 1); + constexpr uint redMask = ((1 << redWidth<Format>()) - 1); + constexpr uint greenMask = ((1 << greenWidth<Format>()) - 1); + constexpr uint blueMask = ((1 << blueWidth<Format>()) - 1); - Q_CONSTEXPR uchar redLeftShift = 8 - redWidth<Format>(); - Q_CONSTEXPR uchar greenLeftShift = 8 - greenWidth<Format>(); - Q_CONSTEXPR uchar blueLeftShift = 8 - blueWidth<Format>(); + constexpr uchar redLeftShift = 8 - redWidth<Format>(); + constexpr uchar greenLeftShift = 8 - greenWidth<Format>(); + constexpr uchar blueLeftShift = 8 - blueWidth<Format>(); - Q_CONSTEXPR uchar redRightShift = 2 * redWidth<Format>() - 8; - Q_CONSTEXPR uchar greenRightShift = 2 * greenWidth<Format>() - 8; - Q_CONSTEXPR uchar blueRightShift = 2 * blueWidth<Format>() - 8; + constexpr uchar redRightShift = 2 * redWidth<Format>() - 8; + constexpr uchar greenRightShift = 2 * greenWidth<Format>() - 8; + constexpr uchar blueRightShift = 2 * blueWidth<Format>() - 8; uint red = (s >> redShift<Format>()) & redMask; uint green = (s >> greenShift<Format>()) & greenMask; @@ -244,7 +305,7 @@ static Q_ALWAYS_INLINE uint convertPixelToRGB32(uint s) } template<QImage::Format Format> -static void QT_FASTCALL convertToRGB32(uint *buffer, int count, const QVector<QRgb> *) +static void QT_FASTCALL convertToRGB32(uint *buffer, int count, const QList<QRgb> *) { for (int i = 0; i < count; ++i) buffer[i] = convertPixelToRGB32<Format>(buffer[i]); @@ -256,7 +317,7 @@ extern const uint * QT_FASTCALL fetchPixelsBPP24_ssse3(uint *dest, const uchar*s template<QImage::Format Format> static const uint *QT_FASTCALL fetchRGBToRGB32(uint *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { constexpr QPixelLayout::BPP BPP = bitsPerPixel<Format>(); #if defined(__SSE2__) && !defined(__SSSE3__) && QT_COMPILER_SUPPORTS_SSSE3 @@ -269,19 +330,19 @@ static const uint *QT_FASTCALL fetchRGBToRGB32(uint *buffer, const uchar *src, i } #endif for (int i = 0; i < count; ++i) - buffer[i] = convertPixelToRGB32<Format>(qFetchPixel<BPP>(src, index + i)); + buffer[i] = convertPixelToRGB32<Format>(fetchPixel<BPP>(src, index + i)); return buffer; } template<QImage::Format Format> -static Q_ALWAYS_INLINE QRgba64 convertPixelToRGB64(uint s) +static inline QRgba64 convertPixelToRGB64(uint s) { return QRgba64::fromArgb32(convertPixelToRGB32<Format>(s)); } template<QImage::Format Format> static const QRgba64 *QT_FASTCALL convertToRGB64(QRgba64 *buffer, const uint *src, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) buffer[i] = convertPixelToRGB64<Format>(src[i]); @@ -290,32 +351,47 @@ static const QRgba64 *QT_FASTCALL convertToRGB64(QRgba64 *buffer, const uint *sr template<QImage::Format Format> static const QRgba64 *QT_FASTCALL fetchRGBToRGB64(QRgba64 *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) +{ + for (int i = 0; i < count; ++i) + buffer[i] = convertPixelToRGB64<Format>(fetchPixel<bitsPerPixel<Format>()>(src, index + i)); + return buffer; +} + +template<QImage::Format Format> +static Q_ALWAYS_INLINE QRgbaFloat32 convertPixelToRGB32F(uint s) +{ + return QRgbaFloat32::fromArgb32(convertPixelToRGB32<Format>(s)); +} + +template<QImage::Format Format> +static const QRgbaFloat32 *QT_FASTCALL fetchRGBToRGB32F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) - buffer[i] = convertPixelToRGB64<Format>(qFetchPixel<bitsPerPixel<Format>()>(src, index + i)); + buffer[i] = convertPixelToRGB32F<Format>(fetchPixel<bitsPerPixel<Format>()>(src, index + i)); return buffer; } template<QImage::Format Format> -static Q_ALWAYS_INLINE uint convertPixelToARGB32PM(uint s) +static inline uint convertPixelToARGB32PM(uint s) { - Q_CONSTEXPR uint alphaMask = ((1 << alphaWidth<Format>()) - 1); - Q_CONSTEXPR uint redMask = ((1 << redWidth<Format>()) - 1); - Q_CONSTEXPR uint greenMask = ((1 << greenWidth<Format>()) - 1); - Q_CONSTEXPR uint blueMask = ((1 << blueWidth<Format>()) - 1); + constexpr uint alphaMask = ((1 << alphaWidth<Format>()) - 1); + constexpr uint redMask = ((1 << redWidth<Format>()) - 1); + constexpr uint greenMask = ((1 << greenWidth<Format>()) - 1); + constexpr uint blueMask = ((1 << blueWidth<Format>()) - 1); - Q_CONSTEXPR uchar alphaLeftShift = 8 - alphaWidth<Format>(); - Q_CONSTEXPR uchar redLeftShift = 8 - redWidth<Format>(); - Q_CONSTEXPR uchar greenLeftShift = 8 - greenWidth<Format>(); - Q_CONSTEXPR uchar blueLeftShift = 8 - blueWidth<Format>(); + constexpr uchar alphaLeftShift = 8 - alphaWidth<Format>(); + constexpr uchar redLeftShift = 8 - redWidth<Format>(); + constexpr uchar greenLeftShift = 8 - greenWidth<Format>(); + constexpr uchar blueLeftShift = 8 - blueWidth<Format>(); - Q_CONSTEXPR uchar alphaRightShift = 2 * alphaWidth<Format>() - 8; - Q_CONSTEXPR uchar redRightShift = 2 * redWidth<Format>() - 8; - Q_CONSTEXPR uchar greenRightShift = 2 * greenWidth<Format>() - 8; - Q_CONSTEXPR uchar blueRightShift = 2 * blueWidth<Format>() - 8; + constexpr uchar alphaRightShift = 2 * alphaWidth<Format>() - 8; + constexpr uchar redRightShift = 2 * redWidth<Format>() - 8; + constexpr uchar greenRightShift = 2 * greenWidth<Format>() - 8; + constexpr uchar blueRightShift = 2 * blueWidth<Format>() - 8; - Q_CONSTEXPR bool mustMin = (alphaWidth<Format>() != redWidth<Format>()) || + constexpr bool mustMin = (alphaWidth<Format>() != redWidth<Format>()) || (alphaWidth<Format>() != greenWidth<Format>()) || (alphaWidth<Format>() != blueWidth<Format>()); @@ -339,7 +415,7 @@ static Q_ALWAYS_INLINE uint convertPixelToARGB32PM(uint s) } template<QImage::Format Format> -static void QT_FASTCALL convertARGBPMToARGB32PM(uint *buffer, int count, const QVector<QRgb> *) +static void QT_FASTCALL convertARGBPMToARGB32PM(uint *buffer, int count, const QList<QRgb> *) { for (int i = 0; i < count; ++i) buffer[i] = convertPixelToARGB32PM<Format>(buffer[i]); @@ -347,7 +423,7 @@ static void QT_FASTCALL convertARGBPMToARGB32PM(uint *buffer, int count, const Q template<QImage::Format Format> static const uint *QT_FASTCALL fetchARGBPMToARGB32PM(uint *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { constexpr QPixelLayout::BPP BPP = bitsPerPixel<Format>(); #if defined(__SSE2__) && !defined(__SSSE3__) && QT_COMPILER_SUPPORTS_SSSE3 @@ -360,19 +436,19 @@ static const uint *QT_FASTCALL fetchARGBPMToARGB32PM(uint *buffer, const uchar * } #endif for (int i = 0; i < count; ++i) - buffer[i] = convertPixelToARGB32PM<Format>(qFetchPixel<BPP>(src, index + i)); + buffer[i] = convertPixelToARGB32PM<Format>(fetchPixel<BPP>(src, index + i)); return buffer; } template<QImage::Format Format> -static Q_ALWAYS_INLINE QRgba64 convertPixelToRGBA64PM(uint s) +static inline QRgba64 convertPixelToRGBA64PM(uint s) { return QRgba64::fromArgb32(convertPixelToARGB32PM<Format>(s)); } template<QImage::Format Format> static const QRgba64 *QT_FASTCALL convertARGBPMToRGBA64PM(QRgba64 *buffer, const uint *src, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) buffer[i] = convertPixelToRGB64<Format>(src[i]); @@ -381,31 +457,57 @@ static const QRgba64 *QT_FASTCALL convertARGBPMToRGBA64PM(QRgba64 *buffer, const template<QImage::Format Format> static const QRgba64 *QT_FASTCALL fetchARGBPMToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { constexpr QPixelLayout::BPP bpp = bitsPerPixel<Format>(); for (int i = 0; i < count; ++i) - buffer[i] = convertPixelToRGBA64PM<Format>(qFetchPixel<bpp>(src, index + i)); + buffer[i] = convertPixelToRGBA64PM<Format>(fetchPixel<bpp>(src, index + i)); + return buffer; +} + +template<QImage::Format Format> +static Q_ALWAYS_INLINE QRgbaFloat32 convertPixelToRGBA32F(uint s) +{ + return QRgbaFloat32::fromArgb32(convertPixelToARGB32PM<Format>(s)); +} + +template<QImage::Format Format> +static const QRgbaFloat32 *QT_FASTCALL fetchARGBPMToRGBA32F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + constexpr QPixelLayout::BPP bpp = bitsPerPixel<Format>(); + for (int i = 0; i < count; ++i) + buffer[i] = convertPixelToRGBA32F<Format>(fetchPixel<bpp>(src, index + i)); + return buffer; +} + +template<QImage::Format Format> +static const QRgbaFloat32 *QT_FASTCALL fetchARGBToRGBA32F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + constexpr QPixelLayout::BPP bpp = bitsPerPixel<Format>(); + for (int i = 0; i < count; ++i) + buffer[i] = convertPixelToRGBA32F<Format>(fetchPixel<bpp>(src, index + i)).premultiplied(); return buffer; } template<QImage::Format Format, bool fromRGB> static void QT_FASTCALL storeRGBFromARGB32PM(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *dither) + const QList<QRgb> *, QDitherInfo *dither) { - Q_CONSTEXPR uchar rWidth = redWidth<Format>(); - Q_CONSTEXPR uchar gWidth = greenWidth<Format>(); - Q_CONSTEXPR uchar bWidth = blueWidth<Format>(); + constexpr uchar rWidth = redWidth<Format>(); + constexpr uchar gWidth = greenWidth<Format>(); + constexpr uchar bWidth = blueWidth<Format>(); constexpr QPixelLayout::BPP BPP = bitsPerPixel<Format>(); // RGB32 -> RGB888 is not a precision loss. if (!dither || (rWidth == 8 && gWidth == 8 && bWidth == 8)) { - Q_CONSTEXPR uint rMask = (1 << redWidth<Format>()) - 1; - Q_CONSTEXPR uint gMask = (1 << greenWidth<Format>()) - 1; - Q_CONSTEXPR uint bMask = (1 << blueWidth<Format>()) - 1; - Q_CONSTEXPR uchar rRightShift = 24 - redWidth<Format>(); - Q_CONSTEXPR uchar gRightShift = 16 - greenWidth<Format>(); - Q_CONSTEXPR uchar bRightShift = 8 - blueWidth<Format>(); + constexpr uint rMask = (1 << redWidth<Format>()) - 1; + constexpr uint gMask = (1 << greenWidth<Format>()) - 1; + constexpr uint bMask = (1 << blueWidth<Format>()) - 1; + constexpr uchar rRightShift = 24 - redWidth<Format>(); + constexpr uchar gRightShift = 16 - greenWidth<Format>(); + constexpr uchar bRightShift = 8 - blueWidth<Format>(); for (int i = 0; i < count; ++i) { const uint c = fromRGB ? src[i] : qUnpremultiply(src[i]); @@ -443,21 +545,21 @@ static void QT_FASTCALL storeRGBFromARGB32PM(uchar *dest, const uint *src, int i template<QImage::Format Format, bool fromRGB> static void QT_FASTCALL storeARGBPMFromARGB32PM(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *dither) + const QList<QRgb> *, QDitherInfo *dither) { constexpr QPixelLayout::BPP BPP = bitsPerPixel<Format>(); if (!dither) { - Q_CONSTEXPR uint aMask = (1 << alphaWidth<Format>()) - 1; - Q_CONSTEXPR uint rMask = (1 << redWidth<Format>()) - 1; - Q_CONSTEXPR uint gMask = (1 << greenWidth<Format>()) - 1; - Q_CONSTEXPR uint bMask = (1 << blueWidth<Format>()) - 1; + constexpr uint aMask = (1 << alphaWidth<Format>()) - 1; + constexpr uint rMask = (1 << redWidth<Format>()) - 1; + constexpr uint gMask = (1 << greenWidth<Format>()) - 1; + constexpr uint bMask = (1 << blueWidth<Format>()) - 1; - Q_CONSTEXPR uchar aRightShift = 32 - alphaWidth<Format>(); - Q_CONSTEXPR uchar rRightShift = 24 - redWidth<Format>(); - Q_CONSTEXPR uchar gRightShift = 16 - greenWidth<Format>(); - Q_CONSTEXPR uchar bRightShift = 8 - blueWidth<Format>(); + constexpr uchar aRightShift = 32 - alphaWidth<Format>(); + constexpr uchar rRightShift = 24 - redWidth<Format>(); + constexpr uchar gRightShift = 16 - greenWidth<Format>(); + constexpr uchar bRightShift = 8 - blueWidth<Format>(); - Q_CONSTEXPR uint aOpaque = aMask << alphaShift<Format>(); + constexpr uint aOpaque = aMask << alphaShift<Format>(); for (int i = 0; i < count; ++i) { const uint c = src[i]; const uint a = fromRGB ? aOpaque : (((c >> aRightShift) & aMask) << alphaShift<Format>()); @@ -467,10 +569,10 @@ static void QT_FASTCALL storeARGBPMFromARGB32PM(uchar *dest, const uint *src, in storePixel<BPP>(dest, index + i, a | r | g | b); }; } else { - Q_CONSTEXPR uchar aWidth = alphaWidth<Format>(); - Q_CONSTEXPR uchar rWidth = redWidth<Format>(); - Q_CONSTEXPR uchar gWidth = greenWidth<Format>(); - Q_CONSTEXPR uchar bWidth = blueWidth<Format>(); + constexpr uchar aWidth = alphaWidth<Format>(); + constexpr uchar rWidth = redWidth<Format>(); + constexpr uchar gWidth = greenWidth<Format>(); + constexpr uchar bWidth = blueWidth<Format>(); const uint *bayer_line = qt_bayer_matrix[dither->y & 15]; for (int i = 0; i < count; ++i) { @@ -503,24 +605,22 @@ static void QT_FASTCALL storeARGBPMFromARGB32PM(uchar *dest, const uint *src, in template<QImage::Format Format> static void QT_FASTCALL rbSwap(uchar *dst, const uchar *src, int count) { - Q_CONSTEXPR uchar aWidth = alphaWidth<Format>(); - Q_CONSTEXPR uchar aShift = alphaShift<Format>(); - Q_CONSTEXPR uchar rWidth = redWidth<Format>(); - Q_CONSTEXPR uchar rShift = redShift<Format>(); - Q_CONSTEXPR uchar gWidth = greenWidth<Format>(); - Q_CONSTEXPR uchar gShift = greenShift<Format>(); - Q_CONSTEXPR uchar bWidth = blueWidth<Format>(); - Q_CONSTEXPR uchar bShift = blueShift<Format>(); -#ifdef Q_COMPILER_CONSTEXPR + constexpr uchar aWidth = alphaWidth<Format>(); + constexpr uchar aShift = alphaShift<Format>(); + constexpr uchar rWidth = redWidth<Format>(); + constexpr uchar rShift = redShift<Format>(); + constexpr uchar gWidth = greenWidth<Format>(); + constexpr uchar gShift = greenShift<Format>(); + constexpr uchar bWidth = blueWidth<Format>(); + constexpr uchar bShift = blueShift<Format>(); static_assert(rWidth == bWidth); -#endif - Q_CONSTEXPR uint redBlueMask = (1 << rWidth) - 1; - Q_CONSTEXPR uint alphaGreenMask = (((1 << aWidth) - 1) << aShift) + constexpr uint redBlueMask = (1 << rWidth) - 1; + constexpr uint alphaGreenMask = (((1 << aWidth) - 1) << aShift) | (((1 << gWidth) - 1) << gShift); constexpr QPixelLayout::BPP bpp = bitsPerPixel<Format>(); for (int i = 0; i < count; ++i) { - const uint c = qFetchPixel<bpp>(src, i); + const uint c = fetchPixel<bpp>(src, i); const uint r = (c >> rShift) & redBlueMask; const uint b = (c >> bShift) & redBlueMask; const uint t = (c & alphaGreenMask) @@ -570,7 +670,49 @@ static void QT_FASTCALL rbSwap_rgb30(uchar *d, const uchar *s, int count) UNALIASED_CONVERSION_LOOP(dest, src, count, qRgbSwapRgb30); } -template<QImage::Format Format> Q_DECL_CONSTEXPR static inline QPixelLayout pixelLayoutRGB() +static void QT_FASTCALL rbSwap_4x16(uchar *d, const uchar *s, int count) +{ + const ushort *src = reinterpret_cast<const ushort *>(s); + ushort *dest = reinterpret_cast<ushort *>(d); + if (src != dest) { + for (int i = 0; i < count; ++i) { + dest[i * 4 + 0] = src[i * 4 + 2]; + dest[i * 4 + 1] = src[i * 4 + 1]; + dest[i * 4 + 2] = src[i * 4 + 0]; + dest[i * 4 + 3] = src[i * 4 + 3]; + } + } else { + for (int i = 0; i < count; ++i) { + const ushort r = src[i * 4 + 0]; + const ushort b = src[i * 4 + 2]; + dest[i * 4 + 0] = b; + dest[i * 4 + 2] = r; + } + } +} + +static void QT_FASTCALL rbSwap_4x32(uchar *d, const uchar *s, int count) +{ + const uint *src = reinterpret_cast<const uint *>(s); + uint *dest = reinterpret_cast<uint *>(d); + if (src != dest) { + for (int i = 0; i < count; ++i) { + dest[i * 4 + 0] = src[i * 4 + 2]; + dest[i * 4 + 1] = src[i * 4 + 1]; + dest[i * 4 + 2] = src[i * 4 + 0]; + dest[i * 4 + 3] = src[i * 4 + 3]; + } + } else { + for (int i = 0; i < count; ++i) { + const uint r = src[i * 4 + 0]; + const uint b = src[i * 4 + 2]; + dest[i * 4 + 0] = b; + dest[i * 4 + 2] = r; + } + } +} + +template<QImage::Format Format> constexpr static inline QPixelLayout pixelLayoutRGB() { return QPixelLayout{ false, @@ -586,7 +728,7 @@ template<QImage::Format Format> Q_DECL_CONSTEXPR static inline QPixelLayout pixe }; } -template<QImage::Format Format> Q_DECL_CONSTEXPR static inline QPixelLayout pixelLayoutARGBPM() +template<QImage::Format Format> constexpr static inline QPixelLayout pixelLayoutARGBPM() { return QPixelLayout{ true, @@ -602,7 +744,7 @@ template<QImage::Format Format> Q_DECL_CONSTEXPR static inline QPixelLayout pixe }; } -static void QT_FASTCALL convertIndexedToARGB32PM(uint *buffer, int count, const QVector<QRgb> *clut) +static void QT_FASTCALL convertIndexedToARGB32PM(uint *buffer, int count, const QList<QRgb> *clut) { for (int i = 0; i < count; ++i) buffer[i] = qPremultiply(clut->at(buffer[i])); @@ -610,10 +752,10 @@ static void QT_FASTCALL convertIndexedToARGB32PM(uint *buffer, int count, const template<QPixelLayout::BPP BPP> static const uint *QT_FASTCALL fetchIndexedToARGB32PM(uint *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *clut, QDitherInfo *) + const QList<QRgb> *clut, QDitherInfo *) { for (int i = 0; i < count; ++i) { - const uint s = qFetchPixel<BPP>(src, index + i); + const uint s = fetchPixel<BPP>(src, index + i); buffer[i] = qPremultiply(clut->at(s)); } return buffer; @@ -621,113 +763,128 @@ static const uint *QT_FASTCALL fetchIndexedToARGB32PM(uint *buffer, const uchar template<QPixelLayout::BPP BPP> static const QRgba64 *QT_FASTCALL fetchIndexedToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *clut, QDitherInfo *) + const QList<QRgb> *clut, QDitherInfo *) { for (int i = 0; i < count; ++i) { - const uint s = qFetchPixel<BPP>(src, index + i); + const uint s = fetchPixel<BPP>(src, index + i); buffer[i] = QRgba64::fromArgb32(clut->at(s)).premultiplied(); } return buffer; } -static const QRgba64 *QT_FASTCALL convertIndexedToRGBA64PM(QRgba64 *buffer, const uint *src, int count, - const QVector<QRgb> *clut, QDitherInfo *) +template<QPixelLayout::BPP BPP> +static const QRgbaFloat32 *QT_FASTCALL fetchIndexedToRGBA32F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *clut, QDitherInfo *) +{ + for (int i = 0; i < count; ++i) { + const uint s = fetchPixel<BPP>(src, index + i); + buffer[i] = QRgbaFloat32::fromArgb32(clut->at(s)).premultiplied(); + } + return buffer; +} + +template<typename QRgba> +static const QRgba *QT_FASTCALL convertIndexedTo(QRgba *buffer, const uint *src, int count, + const QList<QRgb> *clut, QDitherInfo *) { for (int i = 0; i < count; ++i) - buffer[i] = QRgba64::fromArgb32(clut->at(src[i])).premultiplied(); + buffer[i] = QRgba::fromArgb32(clut->at(src[i])).premultiplied(); return buffer; } -static void QT_FASTCALL convertPassThrough(uint *, int, const QVector<QRgb> *) +static void QT_FASTCALL convertPassThrough(uint *, int, const QList<QRgb> *) { } static const uint *QT_FASTCALL fetchPassThrough(uint *, const uchar *src, int index, int, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { return reinterpret_cast<const uint *>(src) + index; } static const QRgba64 *QT_FASTCALL fetchPassThrough64(QRgba64 *, const uchar *src, int index, int, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { return reinterpret_cast<const QRgba64 *>(src) + index; } static void QT_FASTCALL storePassThrough(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { uint *d = reinterpret_cast<uint *>(dest) + index; if (d != src) memcpy(d, src, count * sizeof(uint)); } -static void QT_FASTCALL convertARGB32ToARGB32PM(uint *buffer, int count, const QVector<QRgb> *) +static void QT_FASTCALL convertARGB32ToARGB32PM(uint *buffer, int count, const QList<QRgb> *) { qt_convertARGB32ToARGB32PM(buffer, buffer, count); } static const uint *QT_FASTCALL fetchARGB32ToARGB32PM(uint *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { return qt_convertARGB32ToARGB32PM(buffer, reinterpret_cast<const uint *>(src) + index, count); } -static void QT_FASTCALL convertRGBA8888PMToARGB32PM(uint *buffer, int count, const QVector<QRgb> *) +static void QT_FASTCALL convertRGBA8888PMToARGB32PM(uint *buffer, int count, const QList<QRgb> *) { for (int i = 0; i < count; ++i) buffer[i] = RGBA2ARGB(buffer[i]); } static const uint *QT_FASTCALL fetchRGBA8888PMToARGB32PM(uint *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { const uint *s = reinterpret_cast<const uint *>(src) + index; UNALIASED_CONVERSION_LOOP(buffer, s, count, RGBA2ARGB); return buffer; } -static void QT_FASTCALL convertRGBA8888ToARGB32PM(uint *buffer, int count, const QVector<QRgb> *) +static void QT_FASTCALL convertRGBA8888ToARGB32PM(uint *buffer, int count, const QList<QRgb> *) { qt_convertRGBA8888ToARGB32PM(buffer, buffer, count); } static const uint *QT_FASTCALL fetchRGBA8888ToARGB32PM(uint *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { return qt_convertRGBA8888ToARGB32PM(buffer, reinterpret_cast<const uint *>(src) + index, count); } -static void QT_FASTCALL convertAlpha8ToRGB32(uint *buffer, int count, const QVector<QRgb> *) +static void QT_FASTCALL convertAlpha8ToRGB32(uint *buffer, int count, const QList<QRgb> *) { for (int i = 0; i < count; ++i) buffer[i] = qRgba(0, 0, 0, buffer[i]); } static const uint *QT_FASTCALL fetchAlpha8ToRGB32(uint *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) buffer[i] = qRgba(0, 0, 0, src[index + i]); return buffer; } -static const QRgba64 *QT_FASTCALL convertAlpha8ToRGB64(QRgba64 *buffer, const uint *src, int count, - const QVector<QRgb> *, QDitherInfo *) +template<typename QRgba> +static const QRgba *QT_FASTCALL convertAlpha8To(QRgba *buffer, const uint *src, int count, + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) - buffer[i] = QRgba64::fromRgba(0, 0, 0, src[i]); + buffer[i] = QRgba::fromRgba(0, 0, 0, src[i]); return buffer; } -static const QRgba64 *QT_FASTCALL fetchAlpha8ToRGB64(QRgba64 *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + +template<typename QRgba> +static const QRgba *QT_FASTCALL fetchAlpha8To(QRgba *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) - buffer[i] = QRgba64::fromRgba(0, 0, 0, src[index + i]); + buffer[i] = QRgba::fromRgba(0, 0, 0, src[index + i]); return buffer; } -static void QT_FASTCALL convertGrayscale8ToRGB32(uint *buffer, int count, const QVector<QRgb> *) +static void QT_FASTCALL convertGrayscale8ToRGB32(uint *buffer, int count, const QList<QRgb> *) { for (int i = 0; i < count; ++i) { const uint s = buffer[i]; @@ -736,7 +893,7 @@ static void QT_FASTCALL convertGrayscale8ToRGB32(uint *buffer, int count, const } static const uint *QT_FASTCALL fetchGrayscale8ToRGB32(uint *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) { const uint s = src[index + i]; @@ -745,34 +902,35 @@ static const uint *QT_FASTCALL fetchGrayscale8ToRGB32(uint *buffer, const uchar return buffer; } -static const QRgba64 *QT_FASTCALL convertGrayscale8ToRGB64(QRgba64 *buffer, const uint *src, int count, - const QVector<QRgb> *, QDitherInfo *) +template<typename QRgba> +static const QRgba *QT_FASTCALL convertGrayscale8To(QRgba *buffer, const uint *src, int count, + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) - buffer[i] = QRgba64::fromRgba(src[i], src[i], src[i], 255); + buffer[i] = QRgba::fromRgba(src[i], src[i], src[i], 255); return buffer; } -static const QRgba64 *QT_FASTCALL fetchGrayscale8ToRGB64(QRgba64 *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) +template<typename QRgba> +static const QRgba *QT_FASTCALL fetchGrayscale8To(QRgba *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) { const uint s = src[index + i]; - buffer[i] = QRgba64::fromRgba(s, s, s, 255); + buffer[i] = QRgba::fromRgba(s, s, s, 255); } return buffer; } -static void QT_FASTCALL convertGrayscale16ToRGB32(uint *buffer, int count, const QVector<QRgb> *) +static void QT_FASTCALL convertGrayscale16ToRGB32(uint *buffer, int count, const QList<QRgb> *) { for (int i = 0; i < count; ++i) { const uint x = qt_div_257(buffer[i]); buffer[i] = qRgb(x, x, x); } } - static const uint *QT_FASTCALL fetchGrayscale16ToRGB32(uint *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { const unsigned short *s = reinterpret_cast<const unsigned short *>(src) + index; for (int i = 0; i < count; ++i) { @@ -782,34 +940,35 @@ static const uint *QT_FASTCALL fetchGrayscale16ToRGB32(uint *buffer, const uchar return buffer; } -static const QRgba64 *QT_FASTCALL convertGrayscale16ToRGBA64(QRgba64 *buffer, const uint *src, int count, - const QVector<QRgb> *, QDitherInfo *) +template<typename QRgba> +static const QRgba *QT_FASTCALL convertGrayscale16To(QRgba *buffer, const uint *src, int count, + const QList<QRgb> *, QDitherInfo *) { - const unsigned short *s = reinterpret_cast<const unsigned short *>(src); for (int i = 0; i < count; ++i) - buffer[i] = QRgba64::fromRgba64(s[i], s[i], s[i], 65535); + buffer[i] = QRgba::fromRgba64(src[i], src[i], src[i], 65535); return buffer; } -static const QRgba64 *QT_FASTCALL fetchGrayscale16ToRGBA64(QRgba64 *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) +template<typename QRgba> +static const QRgba *QT_FASTCALL fetchGrayscale16To(QRgba *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) { const unsigned short *s = reinterpret_cast<const unsigned short *>(src) + index; for (int i = 0; i < count; ++i) { - buffer[i] = QRgba64::fromRgba64(s[i], s[i], s[i], 65535); + buffer[i] = QRgba::fromRgba64(s[i], s[i], s[i], 65535); } return buffer; } static void QT_FASTCALL storeARGB32FromARGB32PM(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { uint *d = reinterpret_cast<uint *>(dest) + index; UNALIASED_CONVERSION_LOOP(d, src, count, [](uint c) { return qUnpremultiply(c); }); } static void QT_FASTCALL storeRGBA8888PMFromARGB32PM(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { uint *d = reinterpret_cast<uint *>(dest) + index; UNALIASED_CONVERSION_LOOP(d, src, count, ARGB2RGBA); @@ -970,7 +1129,7 @@ static inline void qConvertARGB32PMToRGBA64PM_neon(QRgba64 *buffer, const uint * #endif static const QRgba64 *QT_FASTCALL convertRGB32ToRGB64(QRgba64 *buffer, const uint *src, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { #ifdef __SSE2__ qConvertARGB32PMToRGBA64PM_sse2<false, true>(buffer, src, count); @@ -984,13 +1143,13 @@ static const QRgba64 *QT_FASTCALL convertRGB32ToRGB64(QRgba64 *buffer, const uin } static const QRgba64 *QT_FASTCALL fetchRGB32ToRGB64(QRgba64 *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { return convertRGB32ToRGB64(buffer, reinterpret_cast<const uint *>(src) + index, count, nullptr, nullptr); } static const QRgba64 *QT_FASTCALL convertARGB32ToRGBA64PM(QRgba64 *buffer, const uint *src, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) buffer[i] = QRgba64::fromArgb32(src[i]).premultiplied(); @@ -998,13 +1157,13 @@ static const QRgba64 *QT_FASTCALL convertARGB32ToRGBA64PM(QRgba64 *buffer, const } static const QRgba64 *QT_FASTCALL fetchARGB32ToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { return convertARGB32ToRGBA64PM(buffer, reinterpret_cast<const uint *>(src) + index, count, nullptr, nullptr); } static const QRgba64 *QT_FASTCALL convertARGB32PMToRGBA64PM(QRgba64 *buffer, const uint *src, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { #ifdef __SSE2__ qConvertARGB32PMToRGBA64PM_sse2<false, false>(buffer, src, count); @@ -1018,22 +1177,33 @@ static const QRgba64 *QT_FASTCALL convertARGB32PMToRGBA64PM(QRgba64 *buffer, con } static const QRgba64 *QT_FASTCALL fetchARGB32PMToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { return convertARGB32PMToRGBA64PM(buffer, reinterpret_cast<const uint *>(src) + index, count, nullptr, nullptr); } static const QRgba64 *QT_FASTCALL fetchRGBA64ToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { const QRgba64 *s = reinterpret_cast<const QRgba64 *>(src) + index; +#ifdef __SSE2__ + for (int i = 0; i < count; ++i) { + const auto a = s[i].alpha(); + __m128i vs = _mm_loadl_epi64((const __m128i *)(s + i)); + __m128i va = _mm_shufflelo_epi16(vs, _MM_SHUFFLE(3, 3, 3, 3)); + vs = multiplyAlpha65535(vs, va); + _mm_storel_epi64((__m128i *)(buffer + i), vs); + buffer[i].setAlpha(a); + } +#else for (int i = 0; i < count; ++i) buffer[i] = QRgba64::fromRgba64(s[i]).premultiplied(); +#endif return buffer; } static const QRgba64 *QT_FASTCALL convertRGBA8888ToRGBA64PM(QRgba64 *buffer, const uint *src, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) buffer[i] = QRgba64::fromArgb32(RGBA2ARGB(src[i])).premultiplied(); @@ -1041,13 +1211,13 @@ static const QRgba64 *QT_FASTCALL convertRGBA8888ToRGBA64PM(QRgba64 *buffer, con } static const QRgba64 *QT_FASTCALL fetchRGBA8888ToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { return convertRGBA8888ToRGBA64PM(buffer, reinterpret_cast<const uint *>(src) + index, count, nullptr, nullptr); } static const QRgba64 *QT_FASTCALL convertRGBA8888PMToRGBA64PM(QRgba64 *buffer, const uint *src, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { #ifdef __SSE2__ qConvertARGB32PMToRGBA64PM_sse2<true, false>(buffer, src, count); @@ -1061,34 +1231,34 @@ static const QRgba64 *QT_FASTCALL convertRGBA8888PMToRGBA64PM(QRgba64 *buffer, c } static const QRgba64 *QT_FASTCALL fetchRGBA8888PMToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { return convertRGBA8888PMToRGBA64PM(buffer, reinterpret_cast<const uint *>(src) + index, count, nullptr, nullptr); } static void QT_FASTCALL storeRGBA8888FromARGB32PM(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { uint *d = reinterpret_cast<uint *>(dest) + index; UNALIASED_CONVERSION_LOOP(d, src, count, [](uint c) { return ARGB2RGBA(qUnpremultiply(c)); }); } static void QT_FASTCALL storeRGBXFromRGB32(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { uint *d = reinterpret_cast<uint *>(dest) + index; UNALIASED_CONVERSION_LOOP(d, src, count, [](uint c) { return ARGB2RGBA(0xff000000 | c); }); } static void QT_FASTCALL storeRGBXFromARGB32PM(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { uint *d = reinterpret_cast<uint *>(dest) + index; UNALIASED_CONVERSION_LOOP(d, src, count, [](uint c) { return ARGB2RGBA(0xff000000 | qUnpremultiply(c)); }); } template<QtPixelOrder PixelOrder> -static void QT_FASTCALL convertA2RGB30PMToARGB32PM(uint *buffer, int count, const QVector<QRgb> *) +static void QT_FASTCALL convertA2RGB30PMToARGB32PM(uint *buffer, int count, const QList<QRgb> *) { for (int i = 0; i < count; ++i) buffer[i] = qConvertA2rgb30ToArgb32<PixelOrder>(buffer[i]); @@ -1096,7 +1266,7 @@ static void QT_FASTCALL convertA2RGB30PMToARGB32PM(uint *buffer, int count, cons template<QtPixelOrder PixelOrder> static const uint *QT_FASTCALL fetchA2RGB30PMToARGB32PM(uint *buffer, const uchar *s, int index, int count, - const QVector<QRgb> *, QDitherInfo *dither) + const QList<QRgb> *, QDitherInfo *dither) { const uint *src = reinterpret_cast<const uint *>(s) + index; if (!dither) { @@ -1167,7 +1337,7 @@ static inline void qConvertA2RGB30PMToRGBA64PM_sse2(QRgba64 *buffer, const uint template<QtPixelOrder PixelOrder> static const QRgba64 *QT_FASTCALL convertA2RGB30PMToRGBA64PM(QRgba64 *buffer, const uint *src, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { #ifdef __SSE2__ qConvertA2RGB30PMToRGBA64PM_sse2<PixelOrder>(buffer, src, count); @@ -1180,14 +1350,52 @@ static const QRgba64 *QT_FASTCALL convertA2RGB30PMToRGBA64PM(QRgba64 *buffer, co template<QtPixelOrder PixelOrder> static const QRgba64 *QT_FASTCALL fetchA2RGB30PMToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { return convertA2RGB30PMToRGBA64PM<PixelOrder>(buffer, reinterpret_cast<const uint *>(src) + index, count, nullptr, nullptr); } +template<enum QtPixelOrder> inline QRgbaFloat32 qConvertA2rgb30ToRgbaFP(uint rgb); + +template<> +inline QRgbaFloat32 qConvertA2rgb30ToRgbaFP<PixelOrderBGR>(uint rgb) +{ + float alpha = (rgb >> 30) * (1.f/3.f); + float blue = ((rgb >> 20) & 0x3ff) * (1.f/1023.f); + float green = ((rgb >> 10) & 0x3ff) * (1.f/1023.f); + float red = (rgb & 0x3ff) * (1.f/1023.f); + return QRgbaFloat32{ red, green, blue, alpha }; +} + +template<> +inline QRgbaFloat32 qConvertA2rgb30ToRgbaFP<PixelOrderRGB>(uint rgb) +{ + float alpha = (rgb >> 30) * (1.f/3.f); + float red = ((rgb >> 20) & 0x3ff) * (1.f/1023.f); + float green = ((rgb >> 10) & 0x3ff) * (1.f/1023.f); + float blue = (rgb & 0x3ff) * (1.f/1023.f); + return QRgbaFloat32{ red, green, blue, alpha }; +} + +template<QtPixelOrder PixelOrder> +static const QRgbaFloat32 *QT_FASTCALL convertA2RGB30PMToRGBA32F(QRgbaFloat32 *buffer, const uint *src, int count, + const QList<QRgb> *, QDitherInfo *) +{ + for (int i = 0; i < count; ++i) + buffer[i] = qConvertA2rgb30ToRgbaFP<PixelOrder>(src[i]); + return buffer; +} + +template<QtPixelOrder PixelOrder> +static const QRgbaFloat32 *QT_FASTCALL fetchRGB30ToRGBA32F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + return convertA2RGB30PMToRGBA32F<PixelOrder>(buffer, reinterpret_cast<const uint *>(src) + index, count, nullptr, nullptr); +} + template<QtPixelOrder PixelOrder> static void QT_FASTCALL storeA2RGB30PMFromARGB32PM(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { uint *d = reinterpret_cast<uint *>(dest) + index; UNALIASED_CONVERSION_LOOP(d, src, count, qConvertArgb32ToA2rgb30<PixelOrder>); @@ -1195,7 +1403,7 @@ static void QT_FASTCALL storeA2RGB30PMFromARGB32PM(uchar *dest, const uint *src, template<QtPixelOrder PixelOrder> static void QT_FASTCALL storeRGB30FromRGB32(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { uint *d = reinterpret_cast<uint *>(dest) + index; UNALIASED_CONVERSION_LOOP(d, src, count, qConvertRgb32ToRgb30<PixelOrder>); @@ -1203,7 +1411,7 @@ static void QT_FASTCALL storeRGB30FromRGB32(uchar *dest, const uint *src, int in template<QtPixelOrder PixelOrder> static void QT_FASTCALL storeRGB30FromARGB32PM(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { uint *d = reinterpret_cast<uint *>(dest) + index; UNALIASED_CONVERSION_LOOP(d, src, count, qConvertRgb32ToRgb30<PixelOrder>); @@ -1256,28 +1464,28 @@ template void qt_convertRGBA64ToARGB32<true>(uint *dst, const QRgba64 *src, int static void QT_FASTCALL storeAlpha8FromARGB32PM(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) dest[index + i] = qAlpha(src[i]); } static void QT_FASTCALL storeGrayscale8FromRGB32(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) dest[index + i] = qGray(src[i]); } static void QT_FASTCALL storeGrayscale8FromARGB32PM(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { for (int i = 0; i < count; ++i) dest[index + i] = qGray(qUnpremultiply(src[i])); } static void QT_FASTCALL storeGrayscale16FromRGB32(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { unsigned short *d = reinterpret_cast<unsigned short *>(dest) + index; for (int i = 0; i < count; ++i) @@ -1285,7 +1493,7 @@ static void QT_FASTCALL storeGrayscale16FromRGB32(uchar *dest, const uint *src, } static void QT_FASTCALL storeGrayscale16FromARGB32PM(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { unsigned short *d = reinterpret_cast<unsigned short *>(dest) + index; for (int i = 0; i < count; ++i) @@ -1293,7 +1501,7 @@ static void QT_FASTCALL storeGrayscale16FromARGB32PM(uchar *dest, const uint *sr } static const uint *QT_FASTCALL fetchRGB64ToRGB32(uint *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { const QRgba64 *s = reinterpret_cast<const QRgba64 *>(src) + index; for (int i = 0; i < count; ++i) @@ -1302,15 +1510,15 @@ static const uint *QT_FASTCALL fetchRGB64ToRGB32(uint *buffer, const uchar *src, } static void QT_FASTCALL storeRGB64FromRGB32(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { QRgba64 *d = reinterpret_cast<QRgba64 *>(dest) + index; for (int i = 0; i < count; ++i) - d[i] = QRgba64::fromArgb32(src[i]); + d[i] = QRgba64::fromArgb32(src[i] | 0xff000000); } static const uint *QT_FASTCALL fetchRGBA64ToARGB32PM(uint *buffer, const uchar *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { const QRgba64 *s = reinterpret_cast<const QRgba64 *>(src) + index; for (int i = 0; i < count; ++i) @@ -1318,30 +1526,214 @@ static const uint *QT_FASTCALL fetchRGBA64ToARGB32PM(uint *buffer, const uchar * return buffer; } +template<bool Mask> static void QT_FASTCALL storeRGBA64FromARGB32PM(uchar *dest, const uint *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { QRgba64 *d = reinterpret_cast<QRgba64 *>(dest) + index; - for (int i = 0; i < count; ++i) + for (int i = 0; i < count; ++i) { d[i] = QRgba64::fromArgb32(src[i]).unpremultiplied(); + if (Mask) + d[i].setAlpha(65535); + } +} + +static void QT_FASTCALL storeRGBA64FromARGB32(uchar *dest, const uint *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgba64 *d = reinterpret_cast<QRgba64 *>(dest) + index; + for (int i = 0; i < count; ++i) + d[i] = QRgba64::fromArgb32(src[i]); +} + +static const uint *QT_FASTCALL fetchRGB16FToRGB32(uint *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgbaFloat16 *s = reinterpret_cast<const QRgbaFloat16 *>(src) + index; + for (int i = 0; i < count; ++i) + buffer[i] = s[i].toArgb32(); + return buffer; +} + +static void QT_FASTCALL storeRGB16FFromRGB32(uchar *dest, const uint *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat16 *d = reinterpret_cast<QRgbaFloat16 *>(dest) + index; + for (int i = 0; i < count; ++i) + d[i] = QRgbaFloat16::fromArgb32(src[i]); +} + +static const uint *QT_FASTCALL fetchRGBA16FToARGB32PM(uint *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgbaFloat16 *s = reinterpret_cast<const QRgbaFloat16 *>(src) + index; + for (int i = 0; i < count; ++i) + buffer[i] = s[i].premultiplied().toArgb32(); + return buffer; +} + +static const QRgba64 *QT_FASTCALL fetchRGBA16FToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgbaFloat16 *s = reinterpret_cast<const QRgbaFloat16 *>(src) + index; + for (int i = 0; i < count; ++i) { + QRgbaFloat16 c = s[i].premultiplied(); + buffer[i] = QRgba64::fromRgba64(c.red16(), c.green16(), c.blue16(), c.alpha16()); + } + return buffer; +} + +static void QT_FASTCALL storeRGBA16FFromARGB32PM(uchar *dest, const uint *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat16 *d = reinterpret_cast<QRgbaFloat16 *>(dest) + index; + for (int i = 0; i < count; ++i) + d[i] = QRgbaFloat16::fromArgb32(src[i]).unpremultiplied(); +} + +static const QRgba64 *QT_FASTCALL fetchRGBA16FPMToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgbaFloat16 *s = reinterpret_cast<const QRgbaFloat16 *>(src) + index; + for (int i = 0; i < count; ++i) { + QRgbaFloat16 c = s[i]; + buffer[i] = QRgba64::fromRgba64(c.red16(), c.green16(), c.blue16(), c.alpha16()); + } + return buffer; +} + +static const uint *QT_FASTCALL fetchRGB32FToRGB32(uint *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgbaFloat32 *s = reinterpret_cast<const QRgbaFloat32 *>(src) + index; + for (int i = 0; i < count; ++i) + buffer[i] = s[i].toArgb32(); + return buffer; +} + +static void QT_FASTCALL storeRGB32FFromRGB32(uchar *dest, const uint *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat32 *d = reinterpret_cast<QRgbaFloat32 *>(dest) + index; + for (int i = 0; i < count; ++i) + d[i] = QRgbaFloat32::fromArgb32(src[i]); +} + +static const uint *QT_FASTCALL fetchRGBA32FToARGB32PM(uint *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgbaFloat32 *s = reinterpret_cast<const QRgbaFloat32 *>(src) + index; + for (int i = 0; i < count; ++i) + buffer[i] = s[i].premultiplied().toArgb32(); + return buffer; +} + +static const QRgba64 *QT_FASTCALL fetchRGBA32FToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgbaFloat32 *s = reinterpret_cast<const QRgbaFloat32 *>(src) + index; + for (int i = 0; i < count; ++i) { + QRgbaFloat32 c = s[i].premultiplied(); + buffer[i] = QRgba64::fromRgba64(c.red16(), c.green16(), c.blue16(), c.alpha16()); + } + return buffer; +} + +static void QT_FASTCALL storeRGBA32FFromARGB32PM(uchar *dest, const uint *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat32 *d = reinterpret_cast<QRgbaFloat32 *>(dest) + index; + for (int i = 0; i < count; ++i) + d[i] = QRgbaFloat32::fromArgb32(src[i]).unpremultiplied(); +} + +static const QRgba64 *QT_FASTCALL fetchRGBA32FPMToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgbaFloat32 *s = reinterpret_cast<const QRgbaFloat32 *>(src) + index; + for (int i = 0; i < count; ++i) { + QRgbaFloat32 c = s[i]; + buffer[i] = QRgba64::fromRgba64(c.red16(), c.green16(), c.blue16(), c.alpha16()); + } + return buffer; +} + +inline const uint *qt_convertCMYK8888ToARGB32PM(uint *buffer, const uint *src, int count) +{ + UNALIASED_CONVERSION_LOOP(buffer, src, count, [](uint s) { + const QColor color = QCmyk32::fromCmyk32(s).toColor(); + return color.rgba(); + }); + return buffer; +} + +static void QT_FASTCALL convertCMYK8888ToARGB32PM(uint *buffer, int count, const QList<QRgb> *) +{ + qt_convertCMYK8888ToARGB32PM(buffer, buffer, count); +} + +static const QRgba64 *QT_FASTCALL convertCMYK8888ToToRGBA64PM(QRgba64 *buffer, const uint *src, int count, + const QList<QRgb> *, QDitherInfo *) +{ + for (int i = 0; i < count; ++i) + buffer[i] = QCmyk32::fromCmyk32(src[i]).toColor().rgba64(); + return buffer; +} + +static const uint *QT_FASTCALL fetchCMYK8888ToARGB32PM(uint *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const uint *s = reinterpret_cast<const uint *>(src) + index; + for (int i = 0; i < count; ++i) + buffer[i] = QCmyk32::fromCmyk32(s[i]).toColor().rgba(); + return buffer; +} + +static const QRgba64 *QT_FASTCALL fetchCMYK8888ToRGBA64PM(QRgba64 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const uint *s = reinterpret_cast<const uint *>(src) + index; + for (int i = 0; i < count; ++i) + buffer[i] = QCmyk32::fromCmyk32(s[i]).toColor().rgba64(); + return buffer; +} + +static void QT_FASTCALL storeCMYK8888FromARGB32PM(uchar *dest, const uint *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + uint *d = reinterpret_cast<uint *>(dest) + index; + for (int i = 0; i < count; ++i) { + QColor c = qUnpremultiply(src[i]); + d[i] = QCmyk32::fromColor(c).toUint(); + } +} + +static void QT_FASTCALL storeCMYK8888FromRGB32(uchar *dest, const uint *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + uint *d = reinterpret_cast<uint *>(dest) + index; + for (int i = 0; i < count; ++i) { + QColor c = src[i]; + d[i] = QCmyk32::fromColor(c).toUint(); + } } // Note: // convertToArgb32() assumes that no color channel is less than 4 bits. // storeRGBFromARGB32PM() assumes that no color channel is more than 8 bits. // QImage::rgbSwapped() assumes that the red and blue color channels have the same number of bits. -QPixelLayout qPixelLayouts[QImage::NImageFormats] = { +QPixelLayout qPixelLayouts[] = { { false, false, QPixelLayout::BPPNone, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }, // Format_Invalid { false, false, QPixelLayout::BPP1MSB, nullptr, - convertIndexedToARGB32PM, convertIndexedToRGBA64PM, + convertIndexedToARGB32PM, convertIndexedTo<QRgba64>, fetchIndexedToARGB32PM<QPixelLayout::BPP1MSB>, fetchIndexedToRGBA64PM<QPixelLayout::BPP1MSB>, nullptr, nullptr }, // Format_Mono { false, false, QPixelLayout::BPP1LSB, nullptr, - convertIndexedToARGB32PM, convertIndexedToRGBA64PM, + convertIndexedToARGB32PM, convertIndexedTo<QRgba64>, fetchIndexedToARGB32PM<QPixelLayout::BPP1LSB>, fetchIndexedToRGBA64PM<QPixelLayout::BPP1LSB>, nullptr, nullptr }, // Format_MonoLSB { false, false, QPixelLayout::BPP8, nullptr, - convertIndexedToARGB32PM, convertIndexedToRGBA64PM, + convertIndexedToARGB32PM, convertIndexedTo<QRgba64>, fetchIndexedToARGB32PM<QPixelLayout::BPP8>, fetchIndexedToRGBA64PM<QPixelLayout::BPP8>, nullptr, nullptr }, // Format_Indexed8 // Technically using convertPassThrough to convert from ARGB32PM to RGB32 is wrong, @@ -1400,33 +1792,61 @@ QPixelLayout qPixelLayouts[QImage::NImageFormats] = { storeRGB30FromRGB32<PixelOrderRGB> }, // Format_A2RGB30_Premultiplied { true, true, QPixelLayout::BPP8, nullptr, - convertAlpha8ToRGB32, convertAlpha8ToRGB64, - fetchAlpha8ToRGB32, fetchAlpha8ToRGB64, + convertAlpha8ToRGB32, convertAlpha8To<QRgba64>, + fetchAlpha8ToRGB32, fetchAlpha8To<QRgba64>, storeAlpha8FromARGB32PM, nullptr }, // Format_Alpha8 { false, false, QPixelLayout::BPP8, nullptr, - convertGrayscale8ToRGB32, convertGrayscale8ToRGB64, - fetchGrayscale8ToRGB32, fetchGrayscale8ToRGB64, + convertGrayscale8ToRGB32, convertGrayscale8To<QRgba64>, + fetchGrayscale8ToRGB32, fetchGrayscale8To<QRgba64>, storeGrayscale8FromARGB32PM, storeGrayscale8FromRGB32 }, // Format_Grayscale8 - { false, false, QPixelLayout::BPP64, nullptr, + { false, false, QPixelLayout::BPP64, rbSwap_4x16, convertPassThrough, nullptr, fetchRGB64ToRGB32, fetchPassThrough64, - storeRGB64FromRGB32, storeRGB64FromRGB32 }, // Format_RGBX64 - { true, false, QPixelLayout::BPP64, nullptr, + storeRGBA64FromARGB32PM<true>, storeRGB64FromRGB32 }, // Format_RGBX64 + { true, false, QPixelLayout::BPP64, rbSwap_4x16, convertARGB32ToARGB32PM, nullptr, fetchRGBA64ToARGB32PM, fetchRGBA64ToRGBA64PM, - storeRGBA64FromARGB32PM, storeRGB64FromRGB32 }, // Format_RGBA64 - { true, true, QPixelLayout::BPP64, nullptr, + storeRGBA64FromARGB32PM<false>, storeRGB64FromRGB32 }, // Format_RGBA64 + { true, true, QPixelLayout::BPP64, rbSwap_4x16, convertPassThrough, nullptr, fetchRGB64ToRGB32, fetchPassThrough64, - storeRGB64FromRGB32, storeRGB64FromRGB32 }, // Format_RGBA64_Premultiplied + storeRGBA64FromARGB32, storeRGB64FromRGB32 }, // Format_RGBA64_Premultiplied { false, false, QPixelLayout::BPP16, nullptr, - convertGrayscale16ToRGB32, convertGrayscale16ToRGBA64, - fetchGrayscale16ToRGB32, fetchGrayscale16ToRGBA64, + convertGrayscale16ToRGB32, convertGrayscale16To<QRgba64>, + fetchGrayscale16ToRGB32, fetchGrayscale16To<QRgba64>, storeGrayscale16FromARGB32PM, storeGrayscale16FromRGB32 }, // Format_Grayscale16 pixelLayoutRGB<QImage::Format_BGR888>(), + { false, false, QPixelLayout::BPP16FPx4, rbSwap_4x16, + convertPassThrough, nullptr, + fetchRGB16FToRGB32, fetchRGBA16FPMToRGBA64PM, + storeRGB16FFromRGB32, storeRGB16FFromRGB32 }, // Format_RGBX16FPx4 + { true, false, QPixelLayout::BPP16FPx4, rbSwap_4x16, + convertARGB32ToARGB32PM, nullptr, + fetchRGBA16FToARGB32PM, fetchRGBA16FToRGBA64PM, + storeRGBA16FFromARGB32PM, storeRGB16FFromRGB32 }, // Format_RGBA16FPx4 + { true, true, QPixelLayout::BPP16FPx4, rbSwap_4x16, + convertPassThrough, nullptr, + fetchRGB16FToRGB32, fetchRGBA16FPMToRGBA64PM, + storeRGB16FFromRGB32, storeRGB16FFromRGB32 }, // Format_RGBA16FPx4_Premultiplied + { false, false, QPixelLayout::BPP32FPx4, rbSwap_4x32, + convertPassThrough, nullptr, + fetchRGB32FToRGB32, fetchRGBA32FPMToRGBA64PM, + storeRGB32FFromRGB32, storeRGB32FFromRGB32 }, // Format_RGBX32FPx4 + { true, false, QPixelLayout::BPP32FPx4, rbSwap_4x32, + convertARGB32ToARGB32PM, nullptr, + fetchRGBA32FToARGB32PM, fetchRGBA32FToRGBA64PM, + storeRGBA32FFromARGB32PM, storeRGB32FFromRGB32 }, // Format_RGBA32FPx4 + { true, true, QPixelLayout::BPP32FPx4, rbSwap_4x32, + convertPassThrough, nullptr, + fetchRGB32FToRGB32, fetchRGBA32FPMToRGBA64PM, + storeRGB32FFromRGB32, storeRGB32FFromRGB32 }, // Format_RGBA32FPx4_Premultiplied + { false, false, QPixelLayout::BPP32, nullptr, + convertCMYK8888ToARGB32PM, convertCMYK8888ToToRGBA64PM, + fetchCMYK8888ToARGB32PM, fetchCMYK8888ToRGBA64PM, + storeCMYK8888FromARGB32PM, storeCMYK8888FromRGB32 }, // Format_CMYK8888 }; -static_assert(sizeof(qPixelLayouts) / sizeof(*qPixelLayouts) == QImage::NImageFormats); +static_assert(std::size(qPixelLayouts) == QImage::NImageFormats); static void QT_FASTCALL convertFromRgb64(uint *dest, const QRgba64 *src, int length) { @@ -1437,7 +1857,7 @@ static void QT_FASTCALL convertFromRgb64(uint *dest, const QRgba64 *src, int len template<QImage::Format format> static void QT_FASTCALL storeGenericFromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, - const QVector<QRgb> *clut, QDitherInfo *dither) + const QList<QRgb> *clut, QDitherInfo *dither) { uint buffer[BufferSize]; convertFromRgb64(buffer, src, count); @@ -1445,7 +1865,7 @@ static void QT_FASTCALL storeGenericFromRGBA64PM(uchar *dest, const QRgba64 *src } static void QT_FASTCALL storeARGB32FromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { uint *d = (uint*)dest + index; for (int i = 0; i < count; ++i) @@ -1453,7 +1873,7 @@ static void QT_FASTCALL storeARGB32FromRGBA64PM(uchar *dest, const QRgba64 *src, } static void QT_FASTCALL storeRGBA8888FromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { uint *d = (uint*)dest + index; for (int i = 0; i < count; ++i) @@ -1462,7 +1882,7 @@ static void QT_FASTCALL storeRGBA8888FromRGBA64PM(uchar *dest, const QRgba64 *sr template<QtPixelOrder PixelOrder> static void QT_FASTCALL storeRGB30FromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { uint *d = (uint*)dest + index; #ifdef __SSE2__ @@ -1474,7 +1894,7 @@ static void QT_FASTCALL storeRGB30FromRGBA64PM(uchar *dest, const QRgba64 *src, } static void QT_FASTCALL storeRGBX64FromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { QRgba64 *d = reinterpret_cast<QRgba64*>(dest) + index; for (int i = 0; i < count; ++i) { @@ -1484,7 +1904,7 @@ static void QT_FASTCALL storeRGBX64FromRGBA64PM(uchar *dest, const QRgba64 *src, } static void QT_FASTCALL storeRGBA64FromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { QRgba64 *d = reinterpret_cast<QRgba64*>(dest) + index; for (int i = 0; i < count; ++i) @@ -1492,7 +1912,7 @@ static void QT_FASTCALL storeRGBA64FromRGBA64PM(uchar *dest, const QRgba64 *src, } static void QT_FASTCALL storeRGBA64PMFromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { QRgba64 *d = reinterpret_cast<QRgba64*>(dest) + index; if (d != src) @@ -1500,7 +1920,7 @@ static void QT_FASTCALL storeRGBA64PMFromRGBA64PM(uchar *dest, const QRgba64 *sr } static void QT_FASTCALL storeGray16FromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, - const QVector<QRgb> *, QDitherInfo *) + const QList<QRgb> *, QDitherInfo *) { quint16 *d = reinterpret_cast<quint16*>(dest) + index; for (int i = 0; i < count; ++i) { @@ -1509,7 +1929,67 @@ static void QT_FASTCALL storeGray16FromRGBA64PM(uchar *dest, const QRgba64 *src, } } -ConvertAndStorePixelsFunc64 qStoreFromRGBA64PM[QImage::NImageFormats] = { +static void QT_FASTCALL storeRGBX16FFromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat16 *d = reinterpret_cast<QRgbaFloat16 *>(dest) + index; + for (int i = 0; i < count; ++i) { + d[i] = qConvertRgb64ToRgbaF16(src[i]).unpremultiplied(); + d[i].setAlpha(1.0); + } +} + +static void QT_FASTCALL storeRGBA16FFromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat16 *d = reinterpret_cast<QRgbaFloat16 *>(dest) + index; + for (int i = 0; i < count; ++i) + d[i] = qConvertRgb64ToRgbaF16(src[i]).unpremultiplied(); +} + +static void QT_FASTCALL storeRGBA16FPMFromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat16 *d = reinterpret_cast<QRgbaFloat16 *>(dest) + index; + for (int i = 0; i < count; ++i) + d[i] = qConvertRgb64ToRgbaF16(src[i]); +} + +static void QT_FASTCALL storeRGBX32FFromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat32 *d = reinterpret_cast<QRgbaFloat32 *>(dest) + index; + for (int i = 0; i < count; ++i) { + d[i] = qConvertRgb64ToRgbaF32(src[i]).unpremultiplied(); + d[i].setAlpha(1.0); + } +} + +static void QT_FASTCALL storeRGBA32FFromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat32 *d = reinterpret_cast<QRgbaFloat32 *>(dest) + index; + for (int i = 0; i < count; ++i) + d[i] = qConvertRgb64ToRgbaF32(src[i]).unpremultiplied(); +} + +static void QT_FASTCALL storeRGBA32FPMFromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat32 *d = reinterpret_cast<QRgbaFloat32 *>(dest) + index; + for (int i = 0; i < count; ++i) + d[i] = qConvertRgb64ToRgbaF32(src[i]); +} + +static void QT_FASTCALL storeCMYKFromRGBA64PM(uchar *dest, const QRgba64 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + uint *d = reinterpret_cast<uint *>(dest) + index; + for (int i = 0; i < count; ++i) + d[i] = QCmyk32::fromColor(QColor(src[i])).toUint(); +} + +ConvertAndStorePixelsFunc64 qStoreFromRGBA64PM[] = { nullptr, nullptr, nullptr, @@ -1540,6 +2020,417 @@ ConvertAndStorePixelsFunc64 qStoreFromRGBA64PM[QImage::NImageFormats] = { storeRGBA64PMFromRGBA64PM, storeGray16FromRGBA64PM, storeGenericFromRGBA64PM<QImage::Format_BGR888>, + storeRGBX16FFromRGBA64PM, + storeRGBA16FFromRGBA64PM, + storeRGBA16FPMFromRGBA64PM, + storeRGBX32FFromRGBA64PM, + storeRGBA32FFromRGBA64PM, + storeRGBA32FPMFromRGBA64PM, + storeCMYKFromRGBA64PM, }; +static_assert(std::size(qStoreFromRGBA64PM) == QImage::NImageFormats); + +#if QT_CONFIG(raster_fp) +static void QT_FASTCALL convertToRgbaF32(QRgbaFloat32 *dest, const uint *src, int length) +{ + for (int i = 0; i < length; ++i) + dest[i] = QRgbaFloat32::fromArgb32(src[i]); +} + +template<QImage::Format format> +static const QRgbaFloat32 * QT_FASTCALL convertGenericToRGBA32F(QRgbaFloat32 *buffer, const uint *src, int count, + const QList<QRgb> *clut, QDitherInfo *) +{ + uint buffer32[BufferSize]; + memcpy(buffer32, src, count * sizeof(uint)); + qPixelLayouts[format].convertToARGB32PM(buffer32, count, clut); + convertToRgbaF32(buffer, buffer32, count); + return buffer; +} + +static const QRgbaFloat32 * QT_FASTCALL convertARGB32ToRGBA32F(QRgbaFloat32 *buffer, const uint *src, int count, + const QList<QRgb> *, QDitherInfo *) +{ + for (int i = 0; i < count; ++i) + buffer[i] = QRgbaFloat32::fromArgb32(src[i]).premultiplied(); + return buffer; +} + +static const QRgbaFloat32 * QT_FASTCALL convertRGBA8888ToRGBA32F(QRgbaFloat32 *buffer, const uint *src, int count, + const QList<QRgb> *, QDitherInfo *) +{ + for (int i = 0; i < count; ++i) + buffer[i] = QRgbaFloat32::fromArgb32(RGBA2ARGB(src[i])).premultiplied(); + return buffer; +} + +template<QtPixelOrder PixelOrder> +static const QRgbaFloat32 * QT_FASTCALL convertRGB30ToRGBA32F(QRgbaFloat32 *buffer, const uint *src, int count, + const QList<QRgb> *, QDitherInfo *) +{ + for (int i = 0; i < count; ++i) { + QRgba64 s = qConvertA2rgb30ToRgb64<PixelOrder>(src[i]); + buffer[i] = QRgbaFloat32::fromRgba64(s.red(), s.green(), s.blue(), s.alpha()); + } + return buffer; +} + +static const QRgbaFloat32 * QT_FASTCALL convertCMYKToRGBA32F(QRgbaFloat32 *buffer, const uint *src, int count, + const QList<QRgb> *, QDitherInfo *) +{ + for (int i = 0; i < count; ++i) + buffer[i] = QRgbaFloat32::fromArgb32(QCmyk32::fromCmyk32(src[i]).toColor().rgba()); + + return buffer; +} + +ConvertToFPFunc qConvertToRGBA32F[] = { + nullptr, + convertIndexedTo<QRgbaFloat32>, + convertIndexedTo<QRgbaFloat32>, + convertIndexedTo<QRgbaFloat32>, + convertGenericToRGBA32F<QImage::Format_RGB32>, + convertARGB32ToRGBA32F, + convertGenericToRGBA32F<QImage::Format_ARGB32_Premultiplied>, + convertGenericToRGBA32F<QImage::Format_RGB16>, + convertGenericToRGBA32F<QImage::Format_ARGB8565_Premultiplied>, + convertGenericToRGBA32F<QImage::Format_RGB666>, + convertGenericToRGBA32F<QImage::Format_ARGB6666_Premultiplied>, + convertGenericToRGBA32F<QImage::Format_RGB555>, + convertGenericToRGBA32F<QImage::Format_ARGB8555_Premultiplied>, + convertGenericToRGBA32F<QImage::Format_RGB888>, + convertGenericToRGBA32F<QImage::Format_RGB444>, + convertGenericToRGBA32F<QImage::Format_ARGB4444_Premultiplied>, + convertGenericToRGBA32F<QImage::Format_RGBX8888>, + convertRGBA8888ToRGBA32F, + convertGenericToRGBA32F<QImage::Format_RGBA8888_Premultiplied>, + convertRGB30ToRGBA32F<PixelOrderBGR>, + convertRGB30ToRGBA32F<PixelOrderBGR>, + convertRGB30ToRGBA32F<PixelOrderRGB>, + convertRGB30ToRGBA32F<PixelOrderRGB>, + convertAlpha8To<QRgbaFloat32>, + convertGrayscale8To<QRgbaFloat32>, + nullptr, + nullptr, + nullptr, + convertGrayscale16To<QRgbaFloat32>, + convertGenericToRGBA32F<QImage::Format_BGR888>, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + nullptr, + convertCMYKToRGBA32F, +}; + +static_assert(std::size(qConvertToRGBA32F) == QImage::NImageFormats); + +static const QRgbaFloat32 *QT_FASTCALL fetchRGBX64ToRGBA32F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgba64 *s = reinterpret_cast<const QRgba64 *>(src) + index; + for (int i = 0; i < count; ++i) { + QRgba64 c = s[i]; + buffer[i] = QRgbaFloat32::fromRgba64(c.red(), c.green(), c.blue(), 65535); + } + return buffer; +} + +static const QRgbaFloat32 *QT_FASTCALL fetchRGBA64ToRGBA32F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgba64 *s = reinterpret_cast<const QRgba64 *>(src) + index; + for (int i = 0; i < count; ++i) + buffer[i] = qConvertRgb64ToRgbaF32(s[i]).premultiplied(); + return buffer; +} + +static const QRgbaFloat32 *QT_FASTCALL fetchRGBA64PMToRGBA32F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgba64 *s = reinterpret_cast<const QRgba64 *>(src) + index; + for (int i = 0; i < count; ++i) + buffer[i] = qConvertRgb64ToRgbaF32(s[i]); + return buffer; +} + +static const QRgbaFloat32 *QT_FASTCALL fetchRGBA16FToRGBA32F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgbaFloat16 *s = reinterpret_cast<const QRgbaFloat16 *>(src) + index; + for (int i = 0; i < count; ++i) { + auto c = s[i].premultiplied(); + buffer[i] = QRgbaFloat32 { c.r, c.g, c.b, c.a}; + } + return buffer; +} + +static const QRgbaFloat32 *QT_FASTCALL fetchRGBA16F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgbaFloat16 *s = reinterpret_cast<const QRgbaFloat16 *>(src) + index; + qFloatFromFloat16((float *)buffer, (const qfloat16 *)s, count * 4); + return buffer; +} + +static const QRgbaFloat32 *QT_FASTCALL fetchRGBA32FToRGBA32F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgbaFloat32 *s = reinterpret_cast<const QRgbaFloat32 *>(src) + index; + for (int i = 0; i < count; ++i) + buffer[i] = s[i].premultiplied(); + return buffer; +} + +static const QRgbaFloat32 *QT_FASTCALL fetchRGBA32F(QRgbaFloat32 *, const uchar *src, int index, int, + const QList<QRgb> *, QDitherInfo *) +{ + const QRgbaFloat32 *s = reinterpret_cast<const QRgbaFloat32 *>(src) + index; + return s; +} + +static const QRgbaFloat32 *QT_FASTCALL fetchCMYKToRGBA32F(QRgbaFloat32 *buffer, const uchar *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + const uint *s = reinterpret_cast<const uint *>(src) + index; + for (int i = 0; i < count; ++i) + buffer[i] = QRgbaFloat32::fromArgb32(QCmyk32::fromCmyk32(s[i]).toColor().rgba()); + + return buffer; +} + +FetchAndConvertPixelsFuncFP qFetchToRGBA32F[] = { + nullptr, + fetchIndexedToRGBA32F<QPixelLayout::BPP1MSB>, + fetchIndexedToRGBA32F<QPixelLayout::BPP1LSB>, + fetchIndexedToRGBA32F<QPixelLayout::BPP8>, + fetchRGBToRGB32F<QImage::Format_RGB32>, + fetchARGBToRGBA32F<QImage::Format_ARGB32>, + fetchARGBPMToRGBA32F<QImage::Format_ARGB32_Premultiplied>, + fetchRGBToRGB32F<QImage::Format_RGB16>, + fetchARGBToRGBA32F<QImage::Format_ARGB8565_Premultiplied>, + fetchRGBToRGB32F<QImage::Format_RGB666>, + fetchARGBToRGBA32F<QImage::Format_ARGB6666_Premultiplied>, + fetchRGBToRGB32F<QImage::Format_RGB555>, + fetchARGBToRGBA32F<QImage::Format_ARGB8555_Premultiplied>, + fetchRGBToRGB32F<QImage::Format_RGB888>, + fetchRGBToRGB32F<QImage::Format_RGB444>, + fetchARGBToRGBA32F<QImage::Format_ARGB4444_Premultiplied>, + fetchRGBToRGB32F<QImage::Format_RGBX8888>, + fetchARGBToRGBA32F<QImage::Format_RGBA8888>, + fetchARGBPMToRGBA32F<QImage::Format_RGBA8888_Premultiplied>, + fetchRGB30ToRGBA32F<PixelOrderBGR>, + fetchRGB30ToRGBA32F<PixelOrderBGR>, + fetchRGB30ToRGBA32F<PixelOrderRGB>, + fetchRGB30ToRGBA32F<PixelOrderRGB>, + fetchAlpha8To<QRgbaFloat32>, + fetchGrayscale8To<QRgbaFloat32>, + fetchRGBX64ToRGBA32F, + fetchRGBA64ToRGBA32F, + fetchRGBA64PMToRGBA32F, + fetchGrayscale16To<QRgbaFloat32>, + fetchRGBToRGB32F<QImage::Format_BGR888>, + fetchRGBA16F, + fetchRGBA16FToRGBA32F, + fetchRGBA16F, + fetchRGBA32F, + fetchRGBA32FToRGBA32F, + fetchRGBA32F, + fetchCMYKToRGBA32F, +}; + +static_assert(std::size(qFetchToRGBA32F) == QImage::NImageFormats); + +static void QT_FASTCALL convertFromRgba32f(uint *dest, const QRgbaFloat32 *src, int length) +{ + for (int i = 0; i < length; ++i) + dest[i] = src[i].toArgb32(); +} + +template<QImage::Format format> +static void QT_FASTCALL storeGenericFromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *clut, QDitherInfo *dither) +{ + uint buffer[BufferSize]; + convertFromRgba32f(buffer, src, count); + qPixelLayouts[format].storeFromARGB32PM(dest, buffer, index, count, clut, dither); +} + +static void QT_FASTCALL storeARGB32FromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + uint *d = (uint*)dest + index; + for (int i = 0; i < count; ++i) + d[i] = src[i].unpremultiplied().toArgb32(); +} + +static void QT_FASTCALL storeRGBA8888FromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + uint *d = (uint*)dest + index; + for (int i = 0; i < count; ++i) + d[i] = ARGB2RGBA(src[i].unpremultiplied().toArgb32()); +} + +template<QtPixelOrder PixelOrder> +static void QT_FASTCALL storeRGB30FromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + uint *d = (uint*)dest + index; + for (int i = 0; i < count; ++i) { + const auto s = src[i]; + d[i] = qConvertRgb64ToRgb30<PixelOrder>(QRgba64::fromRgba64(s.red16(), s.green16(), s.blue16(), s.alpha16())); + } +} + +static void QT_FASTCALL storeRGBX64FromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgba64 *d = reinterpret_cast<QRgba64 *>(dest) + index; + for (int i = 0; i < count; ++i) { + const auto s = src[i].unpremultiplied(); + d[i] = QRgba64::fromRgba64(s.red16(), s.green16(), s.blue16(), 65535); + } +} + +static void QT_FASTCALL storeRGBA64FromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgba64 *d = reinterpret_cast<QRgba64 *>(dest) + index; + for (int i = 0; i < count; ++i) { + const auto s = src[i].unpremultiplied(); + d[i] = QRgba64::fromRgba64(s.red16(), s.green16(), s.blue16(), s.alpha16()); + } +} + +static void QT_FASTCALL storeRGBA64PMFromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgba64 *d = reinterpret_cast<QRgba64 *>(dest) + index; + for (int i = 0; i < count; ++i) + d[i] = QRgba64::fromRgba64(src[i].red16(), src[i].green16(), src[i].blue16(), src[i].alpha16()); +} + +static void QT_FASTCALL storeGray16FromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + quint16 *d = reinterpret_cast<quint16 *>(dest) + index; + for (int i = 0; i < count; ++i) { + auto s = src[i].unpremultiplied(); + d[i] = qGray(s.red16(), s.green16(), s.blue16()); + } +} + +static void QT_FASTCALL storeRGBX16FFromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat16 *d = reinterpret_cast<QRgbaFloat16 *>(dest) + index; + for (int i = 0; i < count; ++i) { + auto s = src[i].unpremultiplied(); + d[i] = QRgbaFloat16{ qfloat16(s.r), qfloat16(s.g), qfloat16(s.b), qfloat16(1.0f) }; + } +} + +static void QT_FASTCALL storeRGBA16FFromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat16 *d = reinterpret_cast<QRgbaFloat16 *>(dest) + index; + for (int i = 0; i < count; ++i) { + auto s = src[i].unpremultiplied(); + d[i] = QRgbaFloat16{ qfloat16(s.r), qfloat16(s.g), qfloat16(s.b), qfloat16(s.a) }; + } +} + +static void QT_FASTCALL storeRGBA16FPMFromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat16 *d = reinterpret_cast<QRgbaFloat16 *>(dest) + index; + qFloatToFloat16((qfloat16 *)d, (const float *)src, count * 4); +} + +static void QT_FASTCALL storeRGBX32FFromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat32 *d = reinterpret_cast<QRgbaFloat32 *>(dest) + index; + for (int i = 0; i < count; ++i) { + auto s = src[i].unpremultiplied(); + s.a = 1.0f; + d[i] = s; + } +} + +static void QT_FASTCALL storeRGBA32FFromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat32 *d = reinterpret_cast<QRgbaFloat32 *>(dest) + index; + for (int i = 0; i < count; ++i) + d[i] = src[i].unpremultiplied(); +} + +static void QT_FASTCALL storeRGBA32FPMFromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + QRgbaFloat32 *d = reinterpret_cast<QRgbaFloat32 *>(dest) + index; + if (d != src) { + for (int i = 0; i < count; ++i) + d[i] = src[i]; + } +} + +static void QT_FASTCALL storeCMYKFromRGBA32F(uchar *dest, const QRgbaFloat32 *src, int index, int count, + const QList<QRgb> *, QDitherInfo *) +{ + uint *d = reinterpret_cast<uint *>(dest) + index; + for (int i = 0; i < count; ++i) { + // Yikes, this really needs enablers in QColor and friends + d[i] = QCmyk32::fromColor(QColor(src[i].toArgb32())).toUint(); + } +} + +ConvertAndStorePixelsFuncFP qStoreFromRGBA32F[] = { + nullptr, + nullptr, + nullptr, + nullptr, + storeGenericFromRGBA32F<QImage::Format_RGB32>, + storeARGB32FromRGBA32F, + storeGenericFromRGBA32F<QImage::Format_ARGB32_Premultiplied>, + storeGenericFromRGBA32F<QImage::Format_RGB16>, + storeGenericFromRGBA32F<QImage::Format_ARGB8565_Premultiplied>, + storeGenericFromRGBA32F<QImage::Format_RGB666>, + storeGenericFromRGBA32F<QImage::Format_ARGB6666_Premultiplied>, + storeGenericFromRGBA32F<QImage::Format_RGB555>, + storeGenericFromRGBA32F<QImage::Format_ARGB8555_Premultiplied>, + storeGenericFromRGBA32F<QImage::Format_RGB888>, + storeGenericFromRGBA32F<QImage::Format_RGB444>, + storeGenericFromRGBA32F<QImage::Format_ARGB4444_Premultiplied>, + storeGenericFromRGBA32F<QImage::Format_RGBX8888>, + storeRGBA8888FromRGBA32F, + storeGenericFromRGBA32F<QImage::Format_RGBA8888_Premultiplied>, + storeRGB30FromRGBA32F<PixelOrderBGR>, + storeRGB30FromRGBA32F<PixelOrderBGR>, + storeRGB30FromRGBA32F<PixelOrderRGB>, + storeRGB30FromRGBA32F<PixelOrderRGB>, + storeGenericFromRGBA32F<QImage::Format_Alpha8>, + storeGenericFromRGBA32F<QImage::Format_Grayscale8>, + storeRGBX64FromRGBA32F, + storeRGBA64FromRGBA32F, + storeRGBA64PMFromRGBA32F, + storeGray16FromRGBA32F, + storeGenericFromRGBA32F<QImage::Format_BGR888>, + storeRGBX16FFromRGBA32F, + storeRGBA16FFromRGBA32F, + storeRGBA16FPMFromRGBA32F, + storeRGBX32FFromRGBA32F, + storeRGBA32FFromRGBA32F, + storeRGBA32FPMFromRGBA32F, + storeCMYKFromRGBA32F, +}; + +static_assert(std::size(qStoreFromRGBA32F) == QImage::NImageFormats); + +#endif // QT_CONFIG(raster_fp) + QT_END_NAMESPACE |