X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=deinterlace_effect_test.cpp;h=dec132246e09a6aef4e40e41faf66fcce38542f2;hp=004e53777cf39cd37ac90902207b9b4a252bcce5;hb=7366e74b75fa1ac3267709c12417179819b86acb;hpb=b3816fb6d789ea3a682193128ea7a00aef8fa91c

diff --git a/deinterlace_effect_test.cpp b/deinterlace_effect_test.cpp
index 004e537..dec1322 100644
--- a/deinterlace_effect_test.cpp
+++ b/deinterlace_effect_test.cpp
@@ -19,7 +19,17 @@ using namespace std;
 
 namespace movit {
 
-TEST(DeinterlaceTest, ConstantColor) {
+class DeinterlaceTest : public testing::TestWithParam<string> {
+protected:
+	DeinterlaceTest() : disabler(GetParam() == "fragment") {}
+	bool should_skip() { return disabler.should_skip(); }
+
+private:
+	DisableComputeShadersTemporarily disabler;
+};
+
+TEST_P(DeinterlaceTest, ConstantColor) {
+	if (should_skip()) return;
 	float data[] = {
 		0.3f, 0.3f,
 		0.3f, 0.3f,
@@ -52,7 +62,8 @@ TEST(DeinterlaceTest, ConstantColor) {
 }
 
 // Also tests that top/bottom change works like expected.
-TEST(DeinterlaceTest, VerticalInterpolation) {
+TEST_P(DeinterlaceTest, VerticalInterpolation) {
+	if (should_skip()) return;
 	const int width = 11;
 	const int height = 2;
 	float data[width * height] = {
@@ -97,7 +108,8 @@ TEST(DeinterlaceTest, VerticalInterpolation) {
 	expect_equal(expected_data_bottom, out_data, width, height * 2);
 }
 
-TEST(DeinterlaceTest, DiagonalInterpolation) {
+TEST_P(DeinterlaceTest, DiagonalInterpolation) {
+	if (should_skip()) return;
 	const int width = 11;
 	const int height = 3;
 	float data[width * height] = {
@@ -145,7 +157,8 @@ TEST(DeinterlaceTest, DiagonalInterpolation) {
 	expect_equal(expected_data_top, out_data, width, height * 2);
 }
 
-TEST(DeinterlaceTest, FlickerBox) {
+TEST_P(DeinterlaceTest, FlickerBox) {
+	if (should_skip()) return;
 	const int width = 4;
 	const int height = 4;
 	float white_data[width * height] = {
@@ -197,20 +210,39 @@ TEST(DeinterlaceTest, FlickerBox) {
 	}
 }
 
+INSTANTIATE_TEST_CASE_P(DeinterlaceTest,
+                        DeinterlaceTest,
+                        testing::Values("fragment", "compute"));
+
 #ifdef HAVE_BENCHMARK
-void BM_DeinterlaceEffect(benchmark::State &state, size_t bytes_per_pixel, MovitPixelFormat input_format, GLenum output_format)
+namespace {
+
+struct TestFormat {
+	MovitPixelFormat input_format;
+	GLenum output_format;
+	size_t bytes_per_pixel;
+};
+TestFormat gray_format = { FORMAT_GRAYSCALE, GL_RED, 1 };
+TestFormat bgra_format = { FORMAT_BGRA_PREMULTIPLIED_ALPHA, GL_BGRA, 4 };
+
+}  // namespace
+
+void BM_DeinterlaceEffect(benchmark::State &state, TestFormat format, bool spatial_interlacing_check, const std::string &shader_type)
 {
+	DisableComputeShadersTemporarily disabler(shader_type == "fragment");
+	if (disabler.should_skip(&state)) return;
+
 	unsigned width = state.range(0), height = state.range(1);
 	unsigned field_height = height / 2;
 
-	unique_ptr<float[]> field1(new float[width * field_height * bytes_per_pixel]);
-	unique_ptr<float[]> field2(new float[width * field_height * bytes_per_pixel]);
-	unique_ptr<float[]> field3(new float[width * field_height * bytes_per_pixel]);
-	unique_ptr<float[]> field4(new float[width * field_height * bytes_per_pixel]);
-	unique_ptr<float[]> field5(new float[width * field_height * bytes_per_pixel]);
-	unique_ptr<float[]> out_data(new float[width * height * bytes_per_pixel]);
+	unique_ptr<float[]> field1(new float[width * field_height * format.bytes_per_pixel]);
+	unique_ptr<float[]> field2(new float[width * field_height * format.bytes_per_pixel]);
+	unique_ptr<float[]> field3(new float[width * field_height * format.bytes_per_pixel]);
+	unique_ptr<float[]> field4(new float[width * field_height * format.bytes_per_pixel]);
+	unique_ptr<float[]> field5(new float[width * field_height * format.bytes_per_pixel]);
+	unique_ptr<float[]> out_data(new float[width * height * format.bytes_per_pixel]);
 
-	for (unsigned i = 0; i < width * field_height * bytes_per_pixel; ++i) {
+	for (unsigned i = 0; i < width * field_height * format.bytes_per_pixel; ++i) {
 		field1[i] = rand();
 		field2[i] = rand();
 		field3[i] = rand();
@@ -219,19 +251,24 @@ void BM_DeinterlaceEffect(benchmark::State &state, size_t bytes_per_pixel, Movit
 	}
 
 	EffectChainTester tester(nullptr, width, height);
-	Effect *input1 = tester.add_input(field1.get(), input_format, COLORSPACE_sRGB, GAMMA_LINEAR, width, field_height);
-	Effect *input2 = tester.add_input(field2.get(), input_format, COLORSPACE_sRGB, GAMMA_LINEAR, width, field_height);
-	Effect *input3 = tester.add_input(field3.get(), input_format, COLORSPACE_sRGB, GAMMA_LINEAR, width, field_height);
-	Effect *input4 = tester.add_input(field4.get(), input_format, COLORSPACE_sRGB, GAMMA_LINEAR, width, field_height);
-	Effect *input5 = tester.add_input(field5.get(), input_format, COLORSPACE_sRGB, GAMMA_LINEAR, width, field_height);
+	Effect *input1 = tester.add_input(field1.get(), format.input_format, COLORSPACE_sRGB, GAMMA_LINEAR, width, field_height);
+	Effect *input2 = tester.add_input(field2.get(), format.input_format, COLORSPACE_sRGB, GAMMA_LINEAR, width, field_height);
+	Effect *input3 = tester.add_input(field3.get(), format.input_format, COLORSPACE_sRGB, GAMMA_LINEAR, width, field_height);
+	Effect *input4 = tester.add_input(field4.get(), format.input_format, COLORSPACE_sRGB, GAMMA_LINEAR, width, field_height);
+	Effect *input5 = tester.add_input(field5.get(), format.input_format, COLORSPACE_sRGB, GAMMA_LINEAR, width, field_height);
 	Effect *deinterlace_effect = tester.get_chain()->add_effect(new DeinterlaceEffect(), input1, input2, input3, input4, input5);
 
 	ASSERT_TRUE(deinterlace_effect->set_int("current_field_position", 0));
+	ASSERT_TRUE(deinterlace_effect->set_int("enable_spatial_interlacing_check", spatial_interlacing_check));
 
-	tester.benchmark(state, out_data.get(), output_format, COLORSPACE_sRGB, GAMMA_LINEAR, OUTPUT_ALPHA_FORMAT_PREMULTIPLIED);
+	tester.benchmark(state, out_data.get(), format.output_format, COLORSPACE_sRGB, GAMMA_LINEAR, OUTPUT_ALPHA_FORMAT_PREMULTIPLIED);
 }
-BENCHMARK_CAPTURE(BM_DeinterlaceEffect, Gray, 1, FORMAT_GRAYSCALE, GL_RED)->Args({720, 576})->Args({1280, 720})->Args({1920, 1080})->UseRealTime()->Unit(benchmark::kMicrosecond);
-BENCHMARK_CAPTURE(BM_DeinterlaceEffect, BGRA, 4, FORMAT_BGRA_PREMULTIPLIED_ALPHA, GL_BGRA)->Args({720, 576})->Args({1280, 720})->Args({1920, 1080})->UseRealTime()->Unit(benchmark::kMicrosecond);
+BENCHMARK_CAPTURE(BM_DeinterlaceEffect, Gray, gray_format, true, "fragment")->Args({720, 576})->Args({1280, 720})->Args({1920, 1080})->UseRealTime()->Unit(benchmark::kMicrosecond);
+BENCHMARK_CAPTURE(BM_DeinterlaceEffect, BGRA, bgra_format, true, "fragment")->Args({720, 576})->Args({1280, 720})->Args({1920, 1080})->UseRealTime()->Unit(benchmark::kMicrosecond);
+BENCHMARK_CAPTURE(BM_DeinterlaceEffect, BGRANoSpatialCheck, bgra_format, false, "fragment")->Args({720, 576})->Args({1280, 720})->Args({1920, 1080})->UseRealTime()->Unit(benchmark::kMicrosecond);
+BENCHMARK_CAPTURE(BM_DeinterlaceEffect, GrayCompute, gray_format, true, "compute")->Args({720, 576})->Args({1280, 720})->Args({1920, 1080})->UseRealTime()->Unit(benchmark::kMicrosecond);
+BENCHMARK_CAPTURE(BM_DeinterlaceEffect, BGRACompute, bgra_format, true, "compute")->Args({720, 576})->Args({1280, 720})->Args({1920, 1080})->UseRealTime()->Unit(benchmark::kMicrosecond);
+BENCHMARK_CAPTURE(BM_DeinterlaceEffect, BGRANoSpatialCheckCompute, bgra_format, false, "compute")->Args({720, 576})->Args({1280, 720})->Args({1920, 1080})->UseRealTime()->Unit(benchmark::kMicrosecond);
 
 #endif