From 245513f7873fca03be3f031beddaca716d7536d9 Mon Sep 17 00:00:00 2001 From: "Steinar H. Gunderson" Date: Thu, 9 Jan 2014 20:55:02 +0100 Subject: [PATCH] Add accuracy unit tests for GammaExpansionEffect. After all the worry about accuracy in the polynomial expansion, I figured it was time to actually add tests verifying the error bounds here in a more reasonable way. The limits are set sort-of randomly, more-or-less to what the new code already handles, rounded up a bit. (The old texture-based code was _way_ worse than this, it seems, probably due to texel center issues.) This also shows that you can probably do 10-bit processing with Movit without losing way too much accuracy, but that 12-bit is too much for fp16 to handle. --- gamma_expansion_effect.cpp | 3 + gamma_expansion_effect_test.cpp | 133 ++++++++++++++++++++++++++++++++ test_util.cpp | 23 ++++++ test_util.h | 1 + 4 files changed, 160 insertions(+) diff --git a/gamma_expansion_effect.cpp b/gamma_expansion_effect.cpp index 5f9423f..bfccaa0 100644 --- a/gamma_expansion_effect.cpp +++ b/gamma_expansion_effect.cpp @@ -74,6 +74,9 @@ void GammaExpansionEffect::set_gl_state(GLuint glsl_program_num, const std::stri // maxerror = 0.000094 // error at beta = 0.000012 // error at 1.0 = 0.000012 + // + // Note that the worst _relative_ error by far is just at the beginning + // of the exponential curve, ie., just around β. set_uniform_float(glsl_program_num, prefix, "linear_scale", 1.0 / 12.92); set_uniform_float(glsl_program_num, prefix, "c0", 0.001324469581); set_uniform_float(glsl_program_num, prefix, "c1", 0.02227416690); diff --git a/gamma_expansion_effect_test.cpp b/gamma_expansion_effect_test.cpp index dc50f91..452b46c 100644 --- a/gamma_expansion_effect_test.cpp +++ b/gamma_expansion_effect_test.cpp @@ -1,5 +1,6 @@ // Unit tests for GammaExpansionEffect. +#include #include #include "gamma_expansion_effect.h" @@ -51,6 +52,37 @@ TEST(GammaExpansionEffectTest, sRGB_AlphaIsUnchanged) { expect_equal(data, out_data, 5, 1); } +TEST(GammaExpansionEffectTest, sRGB_Accuracy) { + float data[256], expected_data[256], out_data[256]; + + for (int i = 0; i < 256; ++i) { + double x = i / 255.0; + + data[i] = x; + + // From the Wikipedia article on sRGB. + if (x < 0.04045) { + expected_data[i] = x / 12.92; + } else { + expected_data[i] = pow((x + 0.055) / 1.055, 2.4); + } + } + + EffectChainTester tester(data, 256, 1, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_sRGB, GL_RGBA32F); + tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR); + + // Accuracy limits; for comparison, limits for a straightforward ALU solution + // (using a branch and pow()) in parenthesis, used as a “high anchor” to + // indicate limitations of float arithmetic etc.: + // + // Maximum absolute error: 0.1% of max energy (0.051%) + // Maximum relative error: 2.5% of correct answer (0.093%) + // 25% of difference to next pixel level (6.18%) + // Allowed RMS error: 0.0001 (0.000010) + // + test_accuracy(expected_data, out_data, 256, 1e-3, 0.025, 0.25, 1e-4); +} + TEST(GammaExpansionEffectTest, Rec709_KeyValues) { float data[] = { 0.0f, 1.0f, @@ -96,6 +128,72 @@ TEST(GammaExpansionEffectTest, Rec709_AlphaIsUnchanged) { expect_equal(data, out_data, 5, 1); } +TEST(GammaExpansionEffectTest, Rec709_Accuracy) { + float data[256], expected_data[256], out_data[256]; + + for (int i = 0; i < 256; ++i) { + double x = i / 255.0; + + data[i] = x; + + // Rec. 2020, page 3. + if (x < 0.018 * 4.5) { + expected_data[i] = x / 4.5; + } else { + expected_data[i] = pow((x + 0.099) / 1.099, 1.0 / 0.45); + } + } + + EffectChainTester tester(data, 256, 1, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_REC_709, GL_RGBA32F); + tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR); + + // Accuracy limits; for comparison, limits for a straightforward ALU solution + // (using a branch and pow()) in parenthesis, used as a “high anchor” to + // indicate limitations of float arithmetic etc.: + // + // Maximum absolute error: 0.1% of max energy (0.046%) + // Maximum relative error: 1.0% of correct answer (0.080%) + // 10% of difference to next pixel level (6.19%) + // Allowed RMS error: 0.0001 (0.000010) + // + test_accuracy(expected_data, out_data, 256, 1e-3, 0.01, 0.1, 1e-4); +} + +// This test tests the same gamma ramp as Rec709_Accuracy, but with 10-bit +// input range and somewhat looser error bounds. (One could claim that this is +// already on the limit of what we can reasonably do with fp16 input, if you +// look at the local relative error.) +TEST(GammaExpansionEffectTest, Rec2020_10Bit_Accuracy) { + float data[1024], expected_data[1024], out_data[1024]; + + for (int i = 0; i < 1024; ++i) { + double x = i / 1023.0; + + data[i] = x; + + // Rec. 2020, page 3. + if (x < 0.018 * 4.5) { + expected_data[i] = x / 4.5; + } else { + expected_data[i] = pow((x + 0.099) / 1.099, 1.0 / 0.45); + } + } + + EffectChainTester tester(data, 1024, 1, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_REC_2020_10_BIT, GL_RGBA32F); + tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR); + + // Accuracy limits; for comparison, limits for a straightforward ALU solution + // (using a branch and pow()) in parenthesis, used as a “high anchor” to + // indicate limitations of float arithmetic etc.: + // + // Maximum absolute error: 0.1% of max energy (0.036%) + // Maximum relative error: 1.0% of correct answer (0.064%) + // 30% of difference to next pixel level (24.9%) + // Allowed RMS error: 0.0001 (0.000005) + // + test_accuracy(expected_data, out_data, 1024, 1e-3, 0.01, 0.30, 1e-4); +} + TEST(GammaExpansionEffectTest, Rec2020_12BitIsVeryCloseToRec709) { float data[256]; for (unsigned i = 0; i < 256; ++i) { @@ -116,3 +214,38 @@ TEST(GammaExpansionEffectTest, Rec2020_12BitIsVeryCloseToRec709) { } EXPECT_GT(sqdiff, 1e-6); } + +// The fp16 _input_ provided by FlatInput is not enough to distinguish between +// all of the possible 12-bit input values (every other level translates to the +// same value). Thus, this test has extremely loose bounds; if we ever decide +// to start supporting fp32, we should re-run this and tighten them a lot. +TEST(GammaExpansionEffectTest, Rec2020_12Bit_Inaccuracy) { + float data[4096], expected_data[4096], out_data[4096]; + + for (int i = 0; i < 4096; ++i) { + double x = i / 4095.0; + + data[i] = x; + + // Rec. 2020, page 3. + if (x < 0.0181 * 4.5) { + expected_data[i] = x / 4.5; + } else { + expected_data[i] = pow((x + 0.0993) / 1.0993, 1.0/0.45); + } + } + + EffectChainTester tester(data, 4096, 1, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_REC_2020_12_BIT, GL_RGBA32F); + tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR); + + // Accuracy limits; for comparison, limits for a straightforward ALU solution + // (using a branch and pow()) in parenthesis, used as a “high anchor” to + // indicate limitations of float arithmetic etc.: + // + // Maximum absolute error: 0.1% of max energy (0.050%) + // Maximum relative error: 1.0% of correct answer (0.050%) + // 250% of difference to next pixel level (100.00%) + // Allowed RMS error: 0.0001 (0.000003) + // + test_accuracy(expected_data, out_data, 4096, 1e-3, 0.01, 2.50, 1e-4); +} diff --git a/test_util.cpp b/test_util.cpp index 190af95..a35bbea 100644 --- a/test_util.cpp +++ b/test_util.cpp @@ -207,3 +207,26 @@ void expect_equal(const unsigned char *ref, const unsigned char *result, unsigne delete[] ref_float; delete[] result_float; } + +void test_accuracy(const float *expected, const float *result, unsigned num_values, double absolute_error_limit, double relative_error_limit, double local_relative_error_limit, double rms_limit) +{ + double squared_difference = 0.0; + for (unsigned i = 0; i < num_values; ++i) { + double absolute_error = fabs(expected[i] - result[i]); + squared_difference += absolute_error * absolute_error; + EXPECT_LT(absolute_error, absolute_error_limit); + + if (expected[i] > 0.0) { + double relative_error = fabs(absolute_error / expected[i]); + + EXPECT_LT(relative_error, relative_error_limit); + } + if (i < num_values - 1) { + double delta = expected[i + 1] - expected[i]; + double local_relative_error = fabs(absolute_error / delta); + EXPECT_LT(local_relative_error, local_relative_error_limit); + } + } + double rms = sqrt(squared_difference) / num_values; + EXPECT_LT(rms, rms_limit); +} diff --git a/test_util.h b/test_util.h index 10ecf9f..992ca46 100644 --- a/test_util.h +++ b/test_util.h @@ -33,5 +33,6 @@ private: void expect_equal(const float *ref, const float *result, unsigned width, unsigned height, float largest_difference_limit = 1.5 / 255.0, float rms_limit = 0.2 / 255.0); void expect_equal(const unsigned char *ref, const unsigned char *result, unsigned width, unsigned height, unsigned largest_difference_limit = 1, float rms_limit = 0.2); +void test_accuracy(const float *expected, const float *result, unsigned num_values, double absolute_error_limit, double relative_error_limit, double local_relative_error_limit, double rms_limit); #endif // !defined(_MOVIT_TEST_UTIL_H) -- 2.39.2