yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/autotests/test_colorspaces.cpp

196 lines
9.4 KiB
C++
Raw Permalink Normal View History

autotests: add very basic ColorDescription mapping test
2023-12-22 19:25:44 +00:00
/*
SPDX-FileCopyrightText: 2023 Xaver Hugl <xaver.hugl@gmail.com>
SPDX-License-Identifier: LGPL-2.0-or-later
*/
#include <QTest>
autotests: add a color pipeline test for identity transformations If identity transformations aren't properly optimized out, we can have additional rounding errors and reduced performance. This test ensures that doesn't happen
2024-07-08 15:31:49 +00:00
#include "core/colorpipeline.h"
autotests: add very basic ColorDescription mapping test
2023-12-22 19:25:44 +00:00
#include "core/colorspace.h"
using namespace KWin;
class TestColorspaces : public QObject
{
Q_OBJECT
public:
TestColorspaces() = default;
private Q_SLOTS:
void roundtripConversion_data();
void roundtripConversion();
core/colorspace: be more robust about edge cases xyz -> xy and xy -> xyz conversions have divisions in them, so we need to handle the edge cases of the divisor being zero. This can happen if an ICC profile is invalid, or if the XYZ color space is used.
2024-08-23 00:14:31 +00:00
void testXYZ_XYconversions();
autotests: add a color pipeline test for identity transformations If identity transformations aren't properly optimized out, we can have additional rounding errors and reduced performance. This test ensures that doesn't happen
2024-07-08 15:31:49 +00:00
void testIdentityTransformation_data();
void testIdentityTransformation();
autotests: add very basic color pipeline test It just tests rec.709 <-> rec.2020 at 0%, 50% and 100% rec.709 luminance, to have a very simple indicator for when something's gone really wrong while working on color pipeline changes
2024-07-08 16:56:09 +00:00
void testColorPipeline_data();
void testColorPipeline();
autotests: add very basic ColorDescription mapping test
2023-12-22 19:25:44 +00:00
};
static bool compareVectors(const QVector3D &one, const QVector3D &two, float maxDifference)
{
const bool ret = std::abs(one.x() - two.x()) <= maxDifference
&& std::abs(one.y() - two.y()) <= maxDifference
&& std::abs(one.z() - two.z()) <= maxDifference;
if (!ret) {
qWarning() << one << "!=" << two << "within" << maxDifference;
}
return ret;
}
autotests/test_colorspaces: add an autotest for non-normalized primaries
2024-02-27 13:49:31 +00:00
static const double s_resolution10bit = std::pow(1.0 / 2.0, 10);
autotests: add very basic ColorDescription mapping test
2023-12-22 19:25:44 +00:00
void TestColorspaces::roundtripConversion_data()
{
QTest::addColumn<NamedColorimetry>("srcColorimetry");
core: add a TransferFunction class and move transfer function functions in there This way it's more obvious where to find them, and the class can be extended with more functionality later, like transfer functions with parameters
2024-07-04 13:16:48 +00:00
QTest::addColumn<TransferFunction::Type>("srcTransferFunction");
autotests: add very basic ColorDescription mapping test
2023-12-22 19:25:44 +00:00
QTest::addColumn<NamedColorimetry>("dstColorimetry");
core: add a TransferFunction class and move transfer function functions in there This way it's more obvious where to find them, and the class can be extended with more functionality later, like transfer functions with parameters
2024-07-04 13:16:48 +00:00
QTest::addColumn<TransferFunction::Type>("dstTransferFunction");
autotests: add very basic ColorDescription mapping test
2023-12-22 19:25:44 +00:00
QTest::addColumn<double>("requiredAccuracy");
core: add a TransferFunction class and move transfer function functions in there This way it's more obvious where to find them, and the class can be extended with more functionality later, like transfer functions with parameters
2024-07-04 13:16:48 +00:00
QTest::addRow("BT709 (sRGB) <-> BT2020 (linear)") << NamedColorimetry::BT709 << TransferFunction::sRGB << NamedColorimetry::BT2020 << TransferFunction::linear << s_resolution10bit;
QTest::addRow("BT709 (gamma 2.2) <-> BT2020 (linear)") << NamedColorimetry::BT709 << TransferFunction::gamma22 << NamedColorimetry::BT2020 << TransferFunction::linear << s_resolution10bit;
QTest::addRow("BT709 (linear) <-> BT2020 (linear)") << NamedColorimetry::BT709 << TransferFunction::linear << NamedColorimetry::BT2020 << TransferFunction::linear << s_resolution10bit;
QTest::addRow("BT709 (PQ) <-> BT2020 (linear)") << NamedColorimetry::BT709 << TransferFunction::PerceptualQuantizer << NamedColorimetry::BT2020 << TransferFunction::linear << 3 * s_resolution10bit;
autotests: add very basic ColorDescription mapping test
2023-12-22 19:25:44 +00:00
}
void TestColorspaces::roundtripConversion()
{
QFETCH(NamedColorimetry, srcColorimetry);
core: add a TransferFunction class and move transfer function functions in there This way it's more obvious where to find them, and the class can be extended with more functionality later, like transfer functions with parameters
2024-07-04 13:16:48 +00:00
QFETCH(TransferFunction::Type, srcTransferFunction);
autotests: add very basic ColorDescription mapping test
2023-12-22 19:25:44 +00:00
QFETCH(NamedColorimetry, dstColorimetry);
core: add a TransferFunction class and move transfer function functions in there This way it's more obvious where to find them, and the class can be extended with more functionality later, like transfer functions with parameters
2024-07-04 13:16:48 +00:00
QFETCH(TransferFunction::Type, dstTransferFunction);
autotests: add very basic ColorDescription mapping test
2023-12-22 19:25:44 +00:00
QFETCH(double, requiredAccuracy);
backends/drm: remove the shadow buffer when possible, and reduce it to 10bpc when not Using the custom values for min. and max. luminance in transfer functions, we can reduce the ranges of values in the shadow buffer to be limited to [0, 1], and with that we can switch from a floating point buffer back to a normalized format. As gamma 2.2 encoding is much more efficient at storing color values, this also drops the buffer from 16bpc down to 10bpc. Furthermore, this offloads the gamma 2.2 -> PQ conversion to KMS when possible, and then uses the scanout buffer with gamma 2.2 encoding directly. This way the shadow buffer gets completely skipped and performance and efficiency get improved a lot. BUG: 491452 CCBUG: 477223
2024-07-09 10:09:33 +00:00
const auto src = ColorDescription(srcColorimetry, TransferFunction(srcTransferFunction), 100, 0, 100, 100);
const auto dst = ColorDescription(dstColorimetry, TransferFunction(dstTransferFunction), 100, 0, 100, 100);
autotests: add very basic ColorDescription mapping test
2023-12-22 19:25:44 +00:00
const QVector3D red(1, 0, 0);
const QVector3D green(0, 1, 0);
const QVector3D blue(0, 0, 1);
const QVector3D white(1, 1, 1);
core/colorspace: add rendering intents Rendering intents describe how to handle mapping between different colorspaces, what to do with out of gamut values and what to do if the whitepoint doesn't match. This way, clients can choose which behavior their content should get.
2024-08-11 23:33:06 +00:00
constexpr std::array renderingIntents = {
RenderingIntent::RelativeColorimetric,
RenderingIntent::AbsoluteColorimetric,
};
for (const RenderingIntent intent : renderingIntents) {
QVERIFY(compareVectors(dst.mapTo(src.mapTo(red, dst, intent), src, intent), red, requiredAccuracy));
QVERIFY(compareVectors(dst.mapTo(src.mapTo(green, dst, intent), src, intent), green, requiredAccuracy));
QVERIFY(compareVectors(dst.mapTo(src.mapTo(blue, dst, intent), src, intent), blue, requiredAccuracy));
QVERIFY(compareVectors(dst.mapTo(src.mapTo(white, dst, intent), src, intent), white, requiredAccuracy));
}
autotests: add very basic ColorDescription mapping test
2023-12-22 19:25:44 +00:00
}
core/colorspace: be more robust about edge cases xyz -> xy and xy -> xyz conversions have divisions in them, so we need to handle the edge cases of the divisor being zero. This can happen if an ICC profile is invalid, or if the XYZ color space is used.
2024-08-23 00:14:31 +00:00
void TestColorspaces::testXYZ_XYconversions()
autotests/test_colorspaces: add an autotest for non-normalized primaries
2024-02-27 13:49:31 +00:00
{
core/colorspace: be more robust about edge cases xyz -> xy and xy -> xyz conversions have divisions in them, so we need to handle the edge cases of the divisor being zero. This can happen if an ICC profile is invalid, or if the XYZ color space is used.
2024-08-23 00:14:31 +00:00
// this test ensures that Colorimetry::xyzToXY and Colorimetry::xyToXYZ can handle weird inputs
// and don't cause crashes
QCOMPARE(Colorimetry::xyzToXY(QVector3D(0, 0, 0)), QVector2D(0, 0));
QCOMPARE_LE(Colorimetry::xyzToXY(QVector3D(100, 100, 100)).y(), 1);
QCOMPARE(Colorimetry::xyToXYZ(QVector2D(0, 0)), QVector3D(0, 1, 0));
QCOMPARE(Colorimetry::xyToXYZ(QVector2D(1, 0)), QVector3D(1, 1, 0));
autotests/test_colorspaces: add an autotest for non-normalized primaries
2024-02-27 13:49:31 +00:00
}
autotests: add a color pipeline test for identity transformations If identity transformations aren't properly optimized out, we can have additional rounding errors and reduced performance. This test ensures that doesn't happen
2024-07-08 15:31:49 +00:00
void TestColorspaces::testIdentityTransformation_data()
{
QTest::addColumn<NamedColorimetry>("colorimetry");
QTest::addColumn<TransferFunction::Type>("transferFunction");
QTest::addRow("BT709 (sRGB)") << NamedColorimetry::BT709 << TransferFunction::sRGB;
QTest::addRow("BT709 (gamma22)") << NamedColorimetry::BT709 << TransferFunction::gamma22;
QTest::addRow("BT709 (PQ)") << NamedColorimetry::BT709 << TransferFunction::PerceptualQuantizer;
QTest::addRow("BT709 (linear)") << NamedColorimetry::BT709 << TransferFunction::linear;
QTest::addRow("BT2020 (sRGB)") << NamedColorimetry::BT2020 << TransferFunction::sRGB;
QTest::addRow("BT2020 (gamma22)") << NamedColorimetry::BT2020 << TransferFunction::gamma22;
QTest::addRow("BT2020 (PQ)") << NamedColorimetry::BT2020 << TransferFunction::PerceptualQuantizer;
QTest::addRow("BT2020 (linear)") << NamedColorimetry::BT2020 << TransferFunction::linear;
}
void TestColorspaces::testIdentityTransformation()
{
QFETCH(NamedColorimetry, colorimetry);
QFETCH(TransferFunction::Type, transferFunction);
autotest/colorspaces: test identity transformations with bpc
2024-08-18 23:22:03 +00:00
const TransferFunction tf(transferFunction);
core/colorpipeline: improve optimization with differing reference luminances This is done by - fixing isFuzzyScalingOnly to not check the [3, 3] component, which is always 1 - making the comparison between transfer functions fuzzy, so small floating point errors don't prevent two practically identical functions to be optimized out - switching manual optimizations to use addMatrix instead, which removes the matrix or replaces it with a multiplier and the autotest is expanded to test transformations between color descriptions with transfer functions and reference luminances that are just scaled versions of each other
2024-08-19 00:50:05 +00:00
const ColorDescription src(colorimetry, tf, 100, tf.minLuminance, tf.maxLuminance, tf.maxLuminance);
const TransferFunction tf2(transferFunction, tf.minLuminance * 1.1, tf.maxLuminance * 1.1);
const ColorDescription dst(colorimetry, tf2, 110, tf2.minLuminance, tf2.maxLuminance, tf2.maxLuminance);
autotests: add a color pipeline test for identity transformations If identity transformations aren't properly optimized out, we can have additional rounding errors and reduced performance. This test ensures that doesn't happen
2024-07-08 15:31:49 +00:00
core/colorspace: add rendering intents Rendering intents describe how to handle mapping between different colorspaces, what to do with out of gamut values and what to do if the whitepoint doesn't match. This way, clients can choose which behavior their content should get.
2024-08-11 23:33:06 +00:00
constexpr std::array renderingIntents = {
RenderingIntent::Perceptual,
RenderingIntent::RelativeColorimetric,
RenderingIntent::AbsoluteColorimetric,
autotest/colorspaces: test identity transformations with bpc
2024-08-18 23:22:03 +00:00
RenderingIntent::RelativeColorimetricWithBPC,
core/colorspace: add rendering intents Rendering intents describe how to handle mapping between different colorspaces, what to do with out of gamut values and what to do if the whitepoint doesn't match. This way, clients can choose which behavior their content should get.
2024-08-11 23:33:06 +00:00
};
for (const RenderingIntent intent : renderingIntents) {
core/colorpipeline: improve optimization with differing reference luminances This is done by - fixing isFuzzyScalingOnly to not check the [3, 3] component, which is always 1 - making the comparison between transfer functions fuzzy, so small floating point errors don't prevent two practically identical functions to be optimized out - switching manual optimizations to use addMatrix instead, which removes the matrix or replaces it with a multiplier and the autotest is expanded to test transformations between color descriptions with transfer functions and reference luminances that are just scaled versions of each other
2024-08-19 00:50:05 +00:00
const auto pipeline = ColorPipeline::create(src, dst, intent);
core/colorspace: add rendering intents Rendering intents describe how to handle mapping between different colorspaces, what to do with out of gamut values and what to do if the whitepoint doesn't match. This way, clients can choose which behavior their content should get.
2024-08-11 23:33:06 +00:00
if (!pipeline.isIdentity()) {
qWarning() << pipeline;
}
QVERIFY(pipeline.isIdentity());
autotests: add a color pipeline test for identity transformations If identity transformations aren't properly optimized out, we can have additional rounding errors and reduced performance. This test ensures that doesn't happen
2024-07-08 15:31:49 +00:00
}
}
autotests: add very basic color pipeline test It just tests rec.709 <-> rec.2020 at 0%, 50% and 100% rec.709 luminance, to have a very simple indicator for when something's gone really wrong while working on color pipeline changes
2024-07-08 16:56:09 +00:00
void TestColorspaces::testColorPipeline_data()
{
QTest::addColumn<ColorDescription>("srcColor");
QTest::addColumn<ColorDescription>("dstColor");
QTest::addColumn<QVector3D>("dstBlack");
QTest::addColumn<QVector3D>("dstGray");
QTest::addColumn<QVector3D>("dstWhite");
core/colorspace: add rendering intents Rendering intents describe how to handle mapping between different colorspaces, what to do with out of gamut values and what to do if the whitepoint doesn't match. This way, clients can choose which behavior their content should get.
2024-08-11 23:33:06 +00:00
QTest::addColumn<RenderingIntent>("intent");
QTest::addRow("sRGB -> rec.2020 relative colorimetric")
<< ColorDescription(NamedColorimetry::BT709, TransferFunction(TransferFunction::gamma22), TransferFunction::defaultReferenceLuminanceFor(TransferFunction::gamma22), 0, std::nullopt, std::nullopt)
<< ColorDescription(NamedColorimetry::BT2020, TransferFunction(TransferFunction::PerceptualQuantizer), 500, 0, std::nullopt, std::nullopt)
core/colorspace: match default luminances with the Wayland protocol It wasn't feasible to do it before, because it made SDR black far too bright, but with black point compensation the result looks as users expect it
2024-08-12 00:26:56 +00:00
<< QVector3D(0.06729, 0.06729, 0.06729)
<< QVector3D(0.51667, 0.51667, 0.51667)
<< QVector3D(0.67658, 0.67658, 0.67658)
core/colorspace: add rendering intents Rendering intents describe how to handle mapping between different colorspaces, what to do with out of gamut values and what to do if the whitepoint doesn't match. This way, clients can choose which behavior their content should get.
2024-08-11 23:33:06 +00:00
<< RenderingIntent::RelativeColorimetric;
QTest::addRow("sRGB -> scRGB relative colorimetric")
<< ColorDescription(NamedColorimetry::BT709, TransferFunction(TransferFunction::gamma22), TransferFunction::defaultReferenceLuminanceFor(TransferFunction::gamma22), 0, std::nullopt, std::nullopt)
<< ColorDescription(NamedColorimetry::BT709, TransferFunction(TransferFunction::linear, 0, 80), 80, 0, std::nullopt, std::nullopt)
core/colorspace: match default luminances with the Wayland protocol It wasn't feasible to do it before, because it made SDR black far too bright, but with black point compensation the result looks as users expect it
2024-08-12 00:26:56 +00:00
<< QVector3D(0.00025, 0.00025, 0.00025)
<< QVector3D(0.217833, 0.217833, 0.217833)
core/colorspace: add rendering intents Rendering intents describe how to handle mapping between different colorspaces, what to do with out of gamut values and what to do if the whitepoint doesn't match. This way, clients can choose which behavior their content should get.
2024-08-11 23:33:06 +00:00
<< QVector3D(1, 1, 1)
<< RenderingIntent::RelativeColorimetric;
autotests/colorspaces: add some test cases for black point compensation
2024-08-13 11:22:16 +00:00
QTest::addRow("sRGB -> rec.2020 relative colorimetric with bpc")
<< ColorDescription(NamedColorimetry::BT709, TransferFunction(TransferFunction::gamma22, 0.2, 80), 80, 0.2, std::nullopt, std::nullopt)
<< ColorDescription(NamedColorimetry::BT2020, TransferFunction(TransferFunction::PerceptualQuantizer, 0.005, 10'000), 500, 0.005, std::nullopt, std::nullopt)
<< QVector3D(0, 0, 0)
<< QVector3D(0.51667, 0.51667, 0.51667)
<< QVector3D(0.67658, 0.67658, 0.67658)
<< RenderingIntent::RelativeColorimetricWithBPC;
QTest::addRow("scRGB -> scRGB relative colorimetric with bpc")
<< ColorDescription(NamedColorimetry::BT709, TransferFunction(TransferFunction::linear, 0, 80), TransferFunction::defaultReferenceLuminanceFor(TransferFunction::gamma22), 0, std::nullopt, std::nullopt)
<< ColorDescription(NamedColorimetry::BT709, TransferFunction(TransferFunction::linear, 8, 80), 80, 8, std::nullopt, std::nullopt)
<< QVector3D(0, 0, 0)
<< QVector3D(0.5, 0.5, 0.5)
<< QVector3D(1, 1, 1)
<< RenderingIntent::RelativeColorimetricWithBPC;
autotests: add very basic color pipeline test It just tests rec.709 <-> rec.2020 at 0%, 50% and 100% rec.709 luminance, to have a very simple indicator for when something's gone really wrong while working on color pipeline changes
2024-07-08 16:56:09 +00:00
}
void TestColorspaces::testColorPipeline()
{
QFETCH(ColorDescription, srcColor);
QFETCH(ColorDescription, dstColor);
QFETCH(QVector3D, dstBlack);
QFETCH(QVector3D, dstGray);
QFETCH(QVector3D, dstWhite);
core/colorspace: add rendering intents Rendering intents describe how to handle mapping between different colorspaces, what to do with out of gamut values and what to do if the whitepoint doesn't match. This way, clients can choose which behavior their content should get.
2024-08-11 23:33:06 +00:00
QFETCH(RenderingIntent, intent);
autotests: add very basic color pipeline test It just tests rec.709 <-> rec.2020 at 0%, 50% and 100% rec.709 luminance, to have a very simple indicator for when something's gone really wrong while working on color pipeline changes
2024-07-08 16:56:09 +00:00
core/colorspace: add rendering intents Rendering intents describe how to handle mapping between different colorspaces, what to do with out of gamut values and what to do if the whitepoint doesn't match. This way, clients can choose which behavior their content should get.
2024-08-11 23:33:06 +00:00
const auto pipeline = ColorPipeline::create(srcColor, dstColor, intent);
autotests: add very basic color pipeline test It just tests rec.709 <-> rec.2020 at 0%, 50% and 100% rec.709 luminance, to have a very simple indicator for when something's gone really wrong while working on color pipeline changes
2024-07-08 16:56:09 +00:00
QVERIFY(compareVectors(pipeline.evaluate(QVector3D(0, 0, 0)), dstBlack, s_resolution10bit));
QVERIFY(compareVectors(pipeline.evaluate(QVector3D(0.5, 0.5, 0.5)), dstGray, s_resolution10bit));
QVERIFY(compareVectors(pipeline.evaluate(QVector3D(1, 1, 1)), dstWhite, s_resolution10bit));
core/colorspace: add rendering intents Rendering intents describe how to handle mapping between different colorspaces, what to do with out of gamut values and what to do if the whitepoint doesn't match. This way, clients can choose which behavior their content should get.
2024-08-11 23:33:06 +00:00
const auto inversePipeline = ColorPipeline::create(dstColor, srcColor, intent);
autotests: add very basic color pipeline test It just tests rec.709 <-> rec.2020 at 0%, 50% and 100% rec.709 luminance, to have a very simple indicator for when something's gone really wrong while working on color pipeline changes
2024-07-08 16:56:09 +00:00
QVERIFY(compareVectors(inversePipeline.evaluate(dstBlack), QVector3D(0, 0, 0), s_resolution10bit));
QVERIFY(compareVectors(inversePipeline.evaluate(dstGray), QVector3D(0.5, 0.5, 0.5), s_resolution10bit));
QVERIFY(compareVectors(inversePipeline.evaluate(dstWhite), QVector3D(1, 1, 1), s_resolution10bit));
}
autotests: add very basic ColorDescription mapping test
2023-12-22 19:25:44 +00:00
QTEST_MAIN(TestColorspaces)
#include "test_colorspaces.moc"
Reference in a new issue Copy permalink