[i-g-t 06/16] tests/kms_color: New subtests for Plane CTM

[Bhanuprakash Modem]

To verify plane CTM, draw 3 rectangles using before colors with the
ctm matrix applied and verify the CRC is equal to using after colors
with an identify ctm matrix.

V2:
* Rebase
v3:
* Rebase
* Dynamic subtests

Cc: Harry Wentland <harry.wentland at amd.com>
Cc: Ville Syrjälä <ville.syrjala at linux.intel.com>
Cc: Pekka Paalanen <ppaalanen at gmail.com>
Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem at intel.com>
---
 tests/kms_color.c | 154 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 154 insertions(+)

diff --git a/tests/kms_color.c b/tests/kms_color.c
index 0fd4a335..c6fd6a6d 100644
--- a/tests/kms_color.c
+++ b/tests/kms_color.c
@@ -890,6 +890,88 @@ static bool plane_degamma_test(data_t *data, igt_plane_t *plane)
 	return ret;
 }
 
+static bool test_plane_ctm(data_t *data,
+			   igt_plane_t *plane,
+			   color_t *before,
+			   color_t *after,
+			   double *ctm_matrix)
+{
+	const double ctm_identity[] = {
+		1.0, 0.0, 0.0,
+		0.0, 1.0, 0.0,
+		0.0, 0.0, 1.0
+	};
+	igt_output_t *output = data->output;
+	igt_display_t *display = &data->display;
+	drmModeModeInfo *mode = data->mode;
+	struct igt_fb fb;
+	igt_crc_t crc_software, crc_hardware;
+	igt_pipe_crc_t *pipe_crc = data->pipe_crc;
+	bool ret = true;
+
+	igt_info("Plane CTM test is running on pipe-%s plane-%d(%s)\n",
+			kmstest_pipe_name(plane->pipe->pipe), plane->index,
+			kmstest_plane_type_name(plane->type));
+
+	igt_require(igt_plane_has_prop(plane, IGT_PLANE_CTM));
+
+	igt_output_set_pipe(output, plane->pipe->pipe);
+
+	/* Create a framebuffer at the size of the output. */
+	igt_assert(igt_create_fb(data->drm_fd,
+			      mode->hdisplay,
+			      mode->vdisplay,
+			      DRM_FORMAT_XRGB8888,
+			      DRM_FORMAT_MOD_LINEAR,
+			      &fb));
+
+	igt_plane_set_fb(plane, &fb);
+
+	/* Disable Pipe color props. */
+	disable_degamma(plane->pipe);
+	disable_gamma(plane->pipe);
+	disable_ctm(plane->pipe);
+
+	disable_plane_gamma(plane);
+	disable_plane_degamma(plane);
+	igt_display_commit2(display, display->is_atomic ?
+				COMMIT_ATOMIC : COMMIT_LEGACY);
+
+	/* Without CTM transformation. */
+	paint_rectangles(data, mode, after, &fb);
+	igt_plane_set_fb(plane, &fb);
+	set_plane_ctm(plane, ctm_identity);
+	igt_display_commit2(display, display->is_atomic ?
+				COMMIT_ATOMIC : COMMIT_LEGACY);
+	igt_wait_for_vblank(data->drm_fd,
+			display->pipes[plane->pipe->pipe].crtc_offset);
+	igt_pipe_crc_collect_crc(pipe_crc, &crc_software);
+
+	/* With CTM transformation. */
+	paint_rectangles(data, mode, before, &fb);
+	igt_plane_set_fb(plane, &fb);
+	set_plane_ctm(plane, ctm_matrix);
+	igt_display_commit2(display, display->is_atomic ?
+				COMMIT_ATOMIC : COMMIT_LEGACY);
+	igt_wait_for_vblank(data->drm_fd,
+			display->pipes[plane->pipe->pipe].crtc_offset);
+	igt_pipe_crc_collect_crc(pipe_crc, &crc_hardware);
+
+	/* Verify that the CRC of the software computed ouutput
+	 * is equal to the CRC of the CTM matrix transformation
+	 * output.
+	 */
+	ret = igt_check_crc_equal(&crc_software, &crc_hardware);
+
+	disable_plane_ctm(plane);
+	igt_plane_set_fb(plane, NULL);
+	igt_output_set_pipe(output, PIPE_NONE);
+	igt_display_commit2(display, display->is_atomic ?
+					COMMIT_ATOMIC : COMMIT_LEGACY);
+
+	return ret;
+}
+
 static void
 prep_pipe(data_t *data, enum pipe p)
 {
@@ -1047,6 +1129,66 @@ run_ctm_tests_for_pipe(data_t *data, enum pipe p,
 	test_cleanup(data);
 }
 
+static void run_ctm_tests_for_plane(data_t *data,
+				    enum pipe pipe,
+				    color_t *expected,
+				    double *ctm,
+				    int iter)
+{
+	igt_plane_t *plane;
+	double delta;
+	color_t red_green_blue[] = {
+		{ 1.0, 0.0, 0.0 },
+		{ 0.0, 1.0, 0.0 },
+		{ 0.0, 0.0, 1.0 }
+	};
+	int last_plane = (&data->display)->pipes[pipe].n_planes - 1;
+
+	test_setup(data, pipe);
+
+	data->color_depth = 8;
+	delta = 1.0 / (1 << data->color_depth);
+	data->drm_format = DRM_FORMAT_XRGB8888;
+	data->mode = igt_output_get_mode(data->output);
+
+	igt_dynamic_f("pipe-%s-%s", kmstest_pipe_name(pipe), data->output->name) {
+		bool result = false;
+		int i, count = 0;
+
+		for_each_plane_on_pipe(&data->display, pipe, plane) {
+			if (!extended && j__ != 0 && j__ != last_plane)
+				continue;
+
+			result = false;
+
+			if (!iter)
+				result |= test_plane_ctm(data, plane,
+							 red_green_blue, expected,
+							 ctm);
+
+			for (i = 0; i < iter; i++) {
+				expected[0].r =
+				expected[1].g =
+				expected[2].b =
+					ctm[0] + delta * (i - (iter/2));
+
+				result |= test_plane_ctm(data, plane,
+							 red_green_blue, expected,
+							 ctm);
+
+				if (result)
+					break;
+			}
+
+			igt_assert(result);
+			count++;
+		}
+
+		if (!count)
+			igt_skip("No valid planes found.\n");
+	}
+}
+
 static void
 run_deep_color_tests_for_pipe(data_t *data, enum pipe p)
 {
@@ -1310,6 +1452,18 @@ run_tests_for_pipe(data_t *data)
 		}
 	}
 
+	for (i = 0; i < ARRAY_SIZE(ctm_tests); i++) {
+		igt_describe_f("%s", ctm_tests[i].desc);
+		igt_subtest_with_dynamic_f("plane-%s", ctm_tests[i].name) {
+			for_each_pipe(&data->display, pipe) {
+				run_ctm_tests_for_plane(data, pipe,
+							ctm_tests[i].colors,
+							ctm_tests[i].ctm,
+							ctm_tests[i].iter);
+			}
+		}
+	}
+
 	igt_fixture
 		igt_require(data->display.is_atomic);
 
-- 
2.35.1