Fix a typo.

[movit] / resample_effect_test.cpp

diff --git a/resample_effect_test.cpp b/resample_effect_test.cpp
index 84f61e78e16381bd70174c4fc470dfcc29591ccf..16bd70c552c5627a63caea619fb913822c3628f1 100644 (file)
--- a/resample_effect_test.cpp
+++ b/resample_effect_test.cpp
@@ -164,8 +164,13 @@ TEST(ResampleEffectTest, UpscaleByThreeGetsCorrectPixelCenters) {
        tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
 
        // We only bother checking that the middle pixel is still correct,
-       // and that symmetry holds.
-       EXPECT_FLOAT_EQ(1.0, out_data[7 * (size * 3) + 7]);
+       // and that symmetry holds. Note that the middle weight in practice
+       // becomes something like 0.99999 due to the normalization
+       // (some supposedly zero weights become 1e-6 or so), and then after
+       // squaring, the error compounds. Ironically, less texture precision
+       // here will give a more accurate result, since the weight can get
+       // rounded towards 1.0.
+       EXPECT_NEAR(1.0, out_data[7 * (size * 3) + 7], 1e-3);
        for (unsigned y = 0; y < size * 3; ++y) {
                for (unsigned x = 0; x < size * 3; ++x) {
                        EXPECT_NEAR(out_data[y * (size * 3) + x], out_data[(size * 3 - y - 1) * (size * 3) + x], 1e-6);
@@ -432,7 +437,7 @@ TEST(ResampleEffectTest, Precision) {
 }
 
 #ifdef HAVE_BENCHMARK
-template<> inline uint8_t from_fp32<uint8_t>(float x) { return x; }
+template<> inline uint8_t from_fp32<uint8_t>(float x) { return lrintf(x * 255.0f); }
 
 template<class T>
 void BM_ResampleEffect(benchmark::State &state, GammaCurve gamma_curve, GLenum output_format, const std::string &shader_type)
@@ -447,7 +452,7 @@ void BM_ResampleEffect(benchmark::State &state, GammaCurve gamma_curve, GLenum o
        unique_ptr<T[]> out_data(new T[out_width * out_height * 4]);
 
        for (unsigned i = 0; i < in_width * in_height * 4; ++i) {
-               data[i] = from_fp32<T>(float(rand()));
+               data[i] = from_fp32<T>(rand() / (RAND_MAX + 1.0));
        }
 
        EffectChainTester tester(nullptr, out_width, out_height, FORMAT_BGRA_POSTMULTIPLIED_ALPHA, COLORSPACE_sRGB, gamma_curve, output_format);
@@ -475,7 +480,7 @@ BENCHMARK_CAPTURE(BM_ResampleEffectHalf, Float16Upscale, GAMMA_LINEAR, "fragment
 BENCHMARK_CAPTURE(BM_ResampleEffectInt8, Int8Downscale, GAMMA_REC_709, "fragment")->Args({1280, 720, 640, 360})->Args({1280, 720, 320, 180})->Args({1280, 720, 321, 181})->UseRealTime()->Unit(benchmark::kMicrosecond);
 BENCHMARK_CAPTURE(BM_ResampleEffectHalf, Float16Downscale, GAMMA_LINEAR, "fragment")->Args({1280, 720, 640, 360})->Args({1280, 720, 320, 180})->Args({1280, 720, 321, 181})->UseRealTime()->Unit(benchmark::kMicrosecond);
 
-void BM_ComputeScalingWeights(benchmark::State &state)
+void BM_ComputeBilinearScalingWeights(benchmark::State &state)
 {
        constexpr unsigned src_size = 1280;
        constexpr unsigned dst_size = 35;
@@ -483,15 +488,15 @@ void BM_ComputeScalingWeights(benchmark::State &state)
        movit_texel_subpixel_precision = 64;  // To get consistent results across GPUs; this is a CPU test.
 
        // One iteration warmup to make sure the Lanczos table is computed.
-       calculate_scaling_weights(src_size, dst_size, 0.999f, 0.0f);
+       calculate_bilinear_scaling_weights(src_size, dst_size, 0.999f, 0.0f);
 
        for (auto _ : state) {
-               ScalingWeights weights = calculate_scaling_weights(src_size, dst_size, 0.999f, 0.0f);
+               ScalingWeights weights = calculate_bilinear_scaling_weights(src_size, dst_size, 0.999f, 0.0f);
        }
 
        movit_texel_subpixel_precision = old_precision;
 }
-BENCHMARK(BM_ComputeScalingWeights)->Unit(benchmark::kMicrosecond);
+BENCHMARK(BM_ComputeBilinearScalingWeights)->Unit(benchmark::kMicrosecond);
 
 #endif