X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=resample_effect_test.cpp;h=71354f209c4a2858553c3f00b939bce3fec1bb70;hp=7955c5ba99f480a94f048385f1697ffa0fb09091;hb=037ee905bc05fcbb278ac3a0b1f73249efada9b2;hpb=e09662ec1b11f72746c7691fef56e14241d32d1c

diff --git a/resample_effect_test.cpp b/resample_effect_test.cpp
index 7955c5b..71354f2 100644
--- a/resample_effect_test.cpp
+++ b/resample_effect_test.cpp
@@ -8,7 +8,9 @@
 
 #include "effect_chain.h"
 #include "flat_input.h"
+#include "fp16.h"
 #include "image_format.h"
+#include "init.h"
 #include "resample_effect.h"
 #include "test_util.h"
 
@@ -162,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);
@@ -430,6 +437,8 @@ TEST(ResampleEffectTest, Precision) {
 }
 
 #ifdef HAVE_BENCHMARK
+template<> inline uint8_t from_fp32<uint8_t>(float x) { return x; }
+
 template<class T>
 void BM_ResampleEffect(benchmark::State &state, GammaCurve gamma_curve, GLenum output_format, const std::string &shader_type)
 {
@@ -443,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] = 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);
@@ -456,9 +465,9 @@ void BM_ResampleEffect(benchmark::State &state, GammaCurve gamma_curve, GLenum o
 	tester.benchmark(state, out_data.get(), GL_BGRA, COLORSPACE_sRGB, gamma_curve, OUTPUT_ALPHA_FORMAT_PREMULTIPLIED);
 }
 
-void BM_ResampleEffectFloat(benchmark::State &state, GammaCurve gamma_curve, const std::string &shader_type)
+void BM_ResampleEffectHalf(benchmark::State &state, GammaCurve gamma_curve, const std::string &shader_type)
 {
-	BM_ResampleEffect<float>(state, gamma_curve, GL_RGBA16F, shader_type);
+	BM_ResampleEffect<fp16_int_t>(state, gamma_curve, GL_RGBA16F, shader_type);
 }
 
 void BM_ResampleEffectInt8(benchmark::State &state, GammaCurve gamma_curve, const std::string &shader_type)
@@ -467,9 +476,27 @@ void BM_ResampleEffectInt8(benchmark::State &state, GammaCurve gamma_curve, cons
 }
 
 BENCHMARK_CAPTURE(BM_ResampleEffectInt8, Int8Upscale, GAMMA_REC_709, "fragment")->Args({640, 360, 1280, 720})->Args({320, 180, 1280, 720})->Args({321, 181, 1280, 720})->UseRealTime()->Unit(benchmark::kMicrosecond);
-BENCHMARK_CAPTURE(BM_ResampleEffectFloat, Float32Upscale, GAMMA_LINEAR, "fragment")->Args({640, 360, 1280, 720})->Args({320, 180, 1280, 720})->Args({321, 181, 1280, 720})->UseRealTime()->Unit(benchmark::kMicrosecond);
+BENCHMARK_CAPTURE(BM_ResampleEffectHalf, Float16Upscale, GAMMA_LINEAR, "fragment")->Args({640, 360, 1280, 720})->Args({320, 180, 1280, 720})->Args({321, 181, 1280, 720})->UseRealTime()->Unit(benchmark::kMicrosecond);
 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_ResampleEffectFloat, Float32Downscale, GAMMA_LINEAR, "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)
+{
+	constexpr unsigned src_size = 1280;
+	constexpr unsigned dst_size = 35;
+	int old_precision = movit_texel_subpixel_precision;
+	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);
+
+	for (auto _ : state) {
+		ScalingWeights weights = calculate_scaling_weights(src_size, dst_size, 0.999f, 0.0f);
+	}
+
+	movit_texel_subpixel_precision = old_precision;
+}
+BENCHMARK(BM_ComputeScalingWeights)->Unit(benchmark::kMicrosecond);
 
 #endif