[i-g-t 09/17] tests/kms_colorop: Add kms_colorop tests
Bhanuprakash Modem
bhanuprakash.modem at intel.com
Fri Jan 12 09:52:55 UTC 2024
From: Harry Wentland <harry.wentland at amd.com>
This tests the color pipeline API, exposed via the
COLOR PIPELINE plane property and drm_colorop objects.
We introduce tests for:
- sRGB EOTF
- sRGB Inverse EOTF
- sRGB EOTF + sRGB Inverse EOTF
The last one is the holy grail of LUT testing. It tests that
after applying an EOTF, followed by its inverse EOTF we arrive
back at the original value. We can use this to test for
precision loss in the pipeline.
All tests are tested via writeback. All transforms are done in
SW (in floating point) and at the end the SW transformed buffer
is compared with the KMS writeback output buffer. The two should
match within a bracket of acceptable deviations. Since these
deviations might look different for different KMS drivers we'll
do this check on a driver-specific basis.
v4: (Bhanu)
- Move few helpers to common place to reuse
v3:
- skip tests if color pipeline not found
- Rename colorop to color_pipeline in places where it refers
to the entire pipeline (Sebastian)
v2:
- Make tests dynamic, allowing definition of tests with an
arbitrary number of transforms
- Add test for sRGB Inverse EOTF
- Add test for sRGB EOTF, followed by sRGB Inverse EOTF
Signed-off-by: Harry Wentland <harry.wentland at amd.com>
Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem at intel.com>
---
lib/igt_color.c | 3 +-
lib/igt_color.h | 4 +-
tests/kms_color_helper.c | 151 ++++++++++++++++
tests/kms_color_helper.h | 57 ++++++
tests/kms_colorop.c | 371 +++++++++++++++++++++++++++++++++++++++
tests/meson.build | 2 +
6 files changed, 585 insertions(+), 3 deletions(-)
create mode 100644 tests/kms_colorop.c
diff --git a/lib/igt_color.c b/lib/igt_color.c
index b8e6a86b0..5355de7ca 100644
--- a/lib/igt_color.c
+++ b/lib/igt_color.c
@@ -13,6 +13,7 @@
#include "igt_core.h"
#include "igt_x86.h"
+const struct igt_color_tf srgb_tf = {2.4f, (float)(1/1.055), (float)(0.055/1.055), (float)(1/12.92), 0.04045f, 0, 0};
static float clamp(float val, float min, float max)
{
@@ -255,4 +256,4 @@ void igt_dump_fb(igt_display_t *display, igt_fb_t *fb,
status = cairo_surface_write_to_png(fb_surface_out, filepath_out);
igt_assert_eq(status, CAIRO_STATUS_SUCCESS);
cairo_surface_destroy(fb_surface_out);
-}
\ No newline at end of file
+}
diff --git a/lib/igt_color.h b/lib/igt_color.h
index ce72a025a..4fffea2c3 100644
--- a/lib/igt_color.h
+++ b/lib/igt_color.h
@@ -19,7 +19,7 @@ struct igt_color_tf {
float g, a,b,c,d,e,f;
};
-const struct igt_color_tf srgb_tf = {2.4f, (float)(1/1.055), (float)(0.055/1.055), (float)(1/12.92), 0.04045f, 0, 0};
+extern const struct igt_color_tf srgb_tf;
typedef struct igt_pixel {
float r;
@@ -40,4 +40,4 @@ int igt_color_transform_pixels(igt_fb_t *fb, igt_pixel_transform transforms[], i
void igt_color_srgb_inv_eotf(igt_pixel_t *pixel);
void igt_color_srgb_eotf(igt_pixel_t *pixel);
-#endif
\ No newline at end of file
+#endif
diff --git a/tests/kms_color_helper.c b/tests/kms_color_helper.c
index 143dff43e..789125e59 100644
--- a/tests/kms_color_helper.c
+++ b/tests/kms_color_helper.c
@@ -388,3 +388,154 @@ void invalid_ctm_matrix_sizes(data_t *data, enum pipe p)
free(ptr);
}
+/* Colorops definitions */
+static bool can_use_colorop(igt_display_t *display, igt_colorop_t *colorop, kms_colorop_t *desired)
+{
+ switch (desired->type) {
+ case KMS_COLOROP_ENUMERATED_LUT1D:
+ if (igt_colorop_get_prop(display, colorop, IGT_COLOROP_TYPE) == DRM_COLOROP_1D_CURVE) {
+ return true;
+ }
+ case KMS_COLOROP_CUSTOM_LUT1D:
+ case KMS_COLOROP_CTM:
+ case KMS_COLOROP_LUT3D:
+ default:
+ return false;
+ }
+}
+
+/**
+ * Iterate color pipeline that begins with colorop and try to map
+ * colorops[] to it.
+ */
+static bool map_to_pipeline(igt_display_t *display,
+ igt_colorop_t *colorop,
+ kms_colorop_t *colorops[])
+{
+ igt_colorop_t *next = colorop;
+ kms_colorop_t *current_op;
+ int i = 0;
+ int prop_val = 0;
+
+ current_op = colorops[i++];
+ if (!current_op)
+ return false;
+
+ while (next) {
+ if (can_use_colorop(display, next, current_op)) {
+ current_op->colorop = next;
+ current_op = colorops[i++];
+ if (!current_op)
+ break;
+ }
+ prop_val = igt_colorop_get_prop(display, next,
+ IGT_COLOROP_NEXT);
+ next = igt_find_colorop(display, prop_val);
+ }
+
+ if (current_op) {
+ /* we failed to map the pipeline */
+
+ /* clean up colorops[i].colorop mappings */
+ for(i = 0, current_op = colorops[0]; current_op; current_op = colorops[i++])
+ current_op->colorop = NULL;
+
+ return false;
+ }
+
+ return true;
+}
+
+igt_colorop_t *get_color_pipeline(igt_display_t *display,
+ igt_plane_t *plane,
+ kms_colorop_t *colorops[])
+{
+ igt_colorop_t *colorop = NULL;
+ int i;
+
+ /* go through all color pipelines */
+ for (i = 0; i < plane->num_color_pipelines; ++i) {
+ if (map_to_pipeline(display, plane->color_pipelines[i], colorops)) {
+ colorop = plane->color_pipelines[i];
+ break;
+ }
+ }
+
+ return colorop;
+}
+
+void set_colorop(igt_display_t *display, kms_colorop_t *colorop)
+{
+ igt_assert(colorop->colorop);
+ igt_colorop_set_prop_value(colorop->colorop, IGT_COLOROP_BYPASS, 0);
+
+ /* TODO set to desired value from kms_colorop_t */
+ switch (colorop->type) {
+ case KMS_COLOROP_ENUMERATED_LUT1D:
+ switch (colorop->enumerated_lut1d_info.tf) {
+ case KMS_COLOROP_LUT1D_SRGB_EOTF:
+ igt_colorop_set_prop_enum(colorop->colorop, IGT_COLOROP_CURVE_1D_TYPE, "sRGB EOTF");
+ break;
+ case KMS_COLOROP_LUT1D_SRGB_INV_EOTF:
+ igt_colorop_set_prop_enum(colorop->colorop, IGT_COLOROP_CURVE_1D_TYPE, "sRGB Inverse EOTF");
+ break;
+ case KMS_COLOROP_LUT1D_PQ_EOTF:
+ case KMS_COLOROP_LUT1D_PQ_INV_EOTF:
+ default:
+ igt_fail(IGT_EXIT_FAILURE);
+ }
+ break;
+ case KMS_COLOROP_CUSTOM_LUT1D:
+ case KMS_COLOROP_CTM:
+ case KMS_COLOROP_LUT3D:
+ default:
+ igt_fail(IGT_EXIT_FAILURE);
+ }
+}
+
+void set_color_pipeline(igt_display_t *display,
+ igt_plane_t *plane,
+ kms_colorop_t *colorops[],
+ igt_colorop_t *color_pipeline)
+{
+ igt_colorop_t *next;
+ int prop_val = 0;
+ int i;
+
+ igt_plane_set_color_pipeline(plane, color_pipeline);
+
+ for(i = 0; colorops[i]; i++)
+ set_colorop(display, colorops[i]);
+
+ /* set unused ops in pipeline to bypass */
+ next = color_pipeline;
+ i = 0;
+ while (next) {
+ if (!colorops[i] || colorops[i]->colorop != next)
+ igt_colorop_set_prop_value(next, IGT_COLOROP_BYPASS, 1);
+ else
+ i++;
+
+ prop_val = igt_colorop_get_prop(display, next,
+ IGT_COLOROP_NEXT);
+ next = igt_find_colorop(display, prop_val);
+ }
+}
+
+kms_colorop_t kms_colorop_srgb_eotf = {
+ .type = KMS_COLOROP_ENUMERATED_LUT1D,
+ .enumerated_lut1d_info = {
+ .tf = KMS_COLOROP_LUT1D_SRGB_EOTF
+ },
+ .name = "srgb_eotf",
+ .transform = &igt_color_srgb_eotf
+};
+
+kms_colorop_t kms_colorop_srgb_inv_eotf = {
+ .type = KMS_COLOROP_ENUMERATED_LUT1D,
+ .enumerated_lut1d_info = {
+ .tf = KMS_COLOROP_LUT1D_SRGB_INV_EOTF
+ },
+ .name = "srgb_inv_eotf",
+ .transform = &igt_color_srgb_inv_eotf
+};
diff --git a/tests/kms_color_helper.h b/tests/kms_color_helper.h
index 23463b944..cc21cb01e 100644
--- a/tests/kms_color_helper.h
+++ b/tests/kms_color_helper.h
@@ -36,6 +36,7 @@
#include "drm.h"
#include "drmtest.h"
#include "igt.h"
+#include "igt_color.h"
#include "igt_edid.h"
@@ -53,6 +54,12 @@ typedef struct {
igt_plane_t *primary;
drmModeModeInfo *mode;
+ bool builtin_mode;
+ bool custom_mode;
+ bool list_modes;
+ bool dump_check;
+ int mode_index;
+
uint32_t drm_format;
uint32_t color_depth;
uint64_t degamma_lut_size;
@@ -115,5 +122,55 @@ void invalid_gamma_lut_sizes(data_t *data, enum pipe p);
void invalid_degamma_lut_sizes(data_t *data, enum pipe p);
void invalid_ctm_matrix_sizes(data_t *data, enum pipe p);
+/* Colorops Test version definitions */
+typedef enum kms_colorop_type {
+ KMS_COLOROP_ENUMERATED_LUT1D,
+ KMS_COLOROP_CUSTOM_LUT1D,
+ KMS_COLOROP_CTM,
+ KMS_COLOROP_LUT3D
+} kms_colorop_type_t;
+
+typedef enum kms_colorop_lut1d_tf {
+ KMS_COLOROP_LUT1D_SRGB_EOTF,
+ KMS_COLOROP_LUT1D_SRGB_INV_EOTF,
+ KMS_COLOROP_LUT1D_PQ_EOTF,
+ KMS_COLOROP_LUT1D_PQ_INV_EOTF,
+} kms_colorop_lut1d_tf_t;
+
+typedef struct kms_colorop_enumerated_lut1d_info {
+ kms_colorop_lut1d_tf_t tf;
+} kms_colorop_enumerated_lut1d_info_t;
+
+typedef struct kms_colorop {
+ kms_colorop_type_t type;
+
+ union {
+ kms_colorop_enumerated_lut1d_info_t enumerated_lut1d_info;
+ };
+
+ const char *name;
+
+ igt_pixel_transform transform;
+
+ /* Mapped colorop */
+ igt_colorop_t *colorop;
+
+} kms_colorop_t;
+
+typedef bool (*compare_fb_t)(igt_fb_t *in, igt_fb_t *out);
+typedef int (*transform_fb)(igt_fb_t *in);
+typedef int (*transform_pixel)(igt_pixel_t *pixel);
+
+extern kms_colorop_t kms_colorop_srgb_eotf;
+extern kms_colorop_t kms_colorop_srgb_inv_eotf;
+
+igt_colorop_t *get_color_pipeline(igt_display_t *display, igt_plane_t *plane,
+ kms_colorop_t *colorops[]);
+void set_colorop(igt_display_t *display, kms_colorop_t *colorop);
+void set_color_pipeline(igt_display_t *display, igt_plane_t *plane,
+ kms_colorop_t *colorops[], igt_colorop_t *color_pipeline);
+
+#define set_color_pipeline_bypass(plane) igt_plane_set_prop_enum((plane), IGT_PLANE_COLOR_PIPELINE, "Bypass")
+
#endif
diff --git a/tests/kms_colorop.c b/tests/kms_colorop.c
new file mode 100644
index 000000000..4e31439a5
--- /dev/null
+++ b/tests/kms_colorop.c
@@ -0,0 +1,371 @@
+/*
+ * Copyright 2023 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "kms_color_helper.h"
+#include "sw_sync.h"
+
+/**
+ * TEST: kms colorop
+ * Category: Display
+ * Description: Test to validate the retrieving and setting of DRM colorops
+ *
+ * SUBTEST: plane-%s
+ * Description: Tests DRM colorop properties on a plane
+ * Driver requirement: amdgpu
+ * Functionality: kms_core
+ * Mega feature: General Display Features
+ * Test category: functionality test
+ *
+ * arg[1]:
+ *
+ * @srgb_eotf: sRGB EOTF
+ * @srgb_inv_eotf: sRGB Inverse EOTF
+ * @srgb_eotf-srgb_inv_eotf: sRGB EOTF -> sRGB Inverse EOTF
+ *
+ */
+
+/* TODO move to lib for kms_writeback and kms_colorop (and other future) use */
+static bool check_writeback_config(igt_display_t *display, igt_output_t *output,
+ drmModeModeInfo override_mode)
+{
+ igt_fb_t input_fb, output_fb;
+ igt_plane_t *plane;
+ uint32_t writeback_format = DRM_FORMAT_XRGB8888;
+ uint64_t modifier = DRM_FORMAT_MOD_LINEAR;
+ int width, height, ret;
+
+ igt_output_override_mode(output, &override_mode);
+
+ width = override_mode.hdisplay;
+ height = override_mode.vdisplay;
+
+ ret = igt_create_fb(display->drm_fd, width, height,
+ DRM_FORMAT_XRGB8888, modifier, &input_fb);
+ igt_assert(ret >= 0);
+
+ ret = igt_create_fb(display->drm_fd, width, height,
+ writeback_format, modifier, &output_fb);
+ igt_assert(ret >= 0);
+
+ plane = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
+ igt_plane_set_fb(plane, &input_fb);
+ igt_output_set_writeback_fb(output, &output_fb);
+
+ ret = igt_display_try_commit_atomic(display, DRM_MODE_ATOMIC_TEST_ONLY |
+ DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
+ igt_plane_set_fb(plane, NULL);
+ igt_remove_fb(display->drm_fd, &input_fb);
+ igt_remove_fb(display->drm_fd, &output_fb);
+
+ return !ret;
+}
+
+static data_t data;
+
+/* TODO move to lib for kms_writeback and kms_colorop (and other future) use */
+static igt_output_t *kms_writeback_get_output(igt_display_t *display)
+{
+ int i;
+ enum pipe pipe;
+
+ drmModeModeInfo override_mode = {
+ .clock = 25175,
+ .hdisplay = 640,
+ .hsync_start = 656,
+ .hsync_end = 752,
+ .htotal = 800,
+ .hskew = 0,
+ .vdisplay = 480,
+ .vsync_start = 490,
+ .vsync_end = 492,
+ .vtotal = 525,
+ .vscan = 0,
+ .vrefresh = 60,
+ .flags = DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC,
+ .name = {"640x480-60"},
+ };
+
+ for (i = 0; i < display->n_outputs; i++) {
+ igt_output_t *output = &display->outputs[i];
+
+ if (output->config.connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK)
+ continue;
+
+ for_each_pipe(display, pipe) {
+ igt_output_set_pipe(output, pipe);
+
+ if (data.custom_mode)
+ override_mode = *data.mode;
+ if (data.builtin_mode)
+ override_mode = output->config.connector->modes[data.mode_index];
+
+ if (check_writeback_config(display, output, override_mode)) {
+ igt_debug("Using connector %u:%s on pipe %d\n",
+ output->config.connector->connector_id,
+ output->name, pipe);
+ return output;
+ }
+ }
+
+ igt_debug("We found %u:%s, but this test will not be able to use it.\n",
+ output->config.connector->connector_id, output->name);
+
+ /* Restore any connectors we don't use, so we don't trip on them later */
+ kmstest_force_connector(display->drm_fd, output->config.connector, FORCE_CONNECTOR_UNSPECIFIED);
+ }
+
+ return NULL;
+}
+
+/* TODO move to lib for kms_writeback and kms_colorop (and other future) use */
+static uint64_t get_writeback_fb_id(igt_output_t *output)
+{
+ return igt_output_get_prop(output, IGT_CONNECTOR_WRITEBACK_FB_ID);
+}
+
+/* TODO move to lib for kms_writeback and kms_colorop (and other future) use */
+static void detach_crtc(igt_display_t *display, igt_output_t *output)
+{
+ if (get_writeback_fb_id(output) == 0)
+ return;
+
+ igt_output_set_pipe(output, PIPE_NONE);
+ igt_display_commit2(display, COMMIT_ATOMIC);
+}
+
+static void get_and_wait_out_fence(igt_output_t *output)
+{
+ int ret;
+
+ igt_assert(output->writeback_out_fence_fd >= 0);
+
+ ret = sync_fence_wait(output->writeback_out_fence_fd, 1000);
+ igt_assert_f(ret == 0, "sync_fence_wait failed: %s\n", strerror(-ret));
+ close(output->writeback_out_fence_fd);
+ output->writeback_out_fence_fd = -1;
+}
+
+static bool compare_with_bracket(igt_fb_t *in, igt_fb_t *out)
+{
+ if (is_vkms_device(in->fd))
+ return igt_cmp_fb_pixels(in, out, 1, 1);
+ else
+ /*
+ * By default we'll look for a [0, 0] bracket. We can then
+ * define it for each driver that implements support for this
+ * test. That way we can understand the precision of each
+ * driver better.
+ */
+ return igt_cmp_fb_pixels(in, out, 0, 0);
+}
+
+#define DUMP_FBS 1
+
+#define MAX_COLOROPS 3
+#define NUM_COLOROP_TESTS 3
+#define MAX_NAME_SIZE 256
+
+static void apply_transforms(kms_colorop_t *colorops[], igt_fb_t *sw_transform_fb)
+{
+ int i;
+ igt_pixel_transform transforms[MAX_COLOROPS];
+
+ /*
+ * TODO
+ *
+ * This is wrong and loses precision since it always goes back
+ * to an 8-bpc framebuffer.
+ *
+ * Instead we need to stay as UNORM or float 16-bpc value throughout
+ * all transforms.
+ */
+
+ for (i = 0; colorops[i]; i++)
+ transforms[i] = colorops[i]->transform;
+
+ igt_color_transform_pixels(sw_transform_fb, transforms, i);
+}
+
+static void colorop_plane_test(igt_display_t *display,
+ kms_colorop_t *colorops[])
+{
+ igt_colorop_t *color_pipeline = NULL;
+ igt_output_t *output;
+ igt_plane_t *plane;
+ igt_fb_t input_fb;
+ igt_fb_t sw_transform_fb;
+ igt_fb_t output_fb;
+ drmModeModeInfo mode;
+ unsigned int fb_id;
+ igt_crc_t input_crc, output_crc;
+
+ output = kms_writeback_get_output(display);
+ igt_require(output);
+
+ if (output->use_override_mode)
+ memcpy(&mode, &output->override_mode, sizeof(mode));
+ else
+ memcpy(&mode, &output->config.default_mode, sizeof(mode));
+
+ /* create input fb */
+ plane = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
+ igt_assert(plane);
+
+ fb_id = igt_create_color_pattern_fb(display->drm_fd,
+ mode.hdisplay, mode.vdisplay,
+ DRM_FORMAT_XRGB8888, DRM_FORMAT_MOD_LINEAR,
+ 0.2, 0.2, 0.2, &input_fb);
+ igt_assert(fb_id >= 0);
+ igt_plane_set_fb(plane, &input_fb);
+#if DUMP_FBS
+ igt_dump_fb(display, &input_fb, ".", "input");
+#endif
+
+ /* create output fb */
+ fb_id = igt_create_fb(display->drm_fd, mode.hdisplay, mode.vdisplay,
+ DRM_FORMAT_XRGB8888,
+ igt_fb_mod_to_tiling(0),
+ &output_fb);
+ igt_require(fb_id > 0);
+
+ igt_fb_get_fnv1a_crc(&input_fb, &input_crc);
+
+ igt_require(igt_plane_has_prop(plane, IGT_PLANE_COLOR_PIPELINE));
+
+ /* reset color pipeline*/
+
+ /* TODO do we need this? might be good sanity anyways */
+ set_color_pipeline_bypass(plane);
+
+ /* Commit */
+ igt_plane_set_fb(plane, &input_fb);
+ igt_output_set_writeback_fb(output, &output_fb);
+
+ igt_display_commit_atomic(output->display,
+ DRM_MODE_ATOMIC_ALLOW_MODESET,
+ NULL);
+ get_and_wait_out_fence(output);
+
+ /* Compare input and output buffers. They should be equal here. */
+ igt_fb_get_fnv1a_crc(&output_fb, &output_crc);
+
+ igt_assert_crc_equal(&input_crc, &output_crc);
+
+ /* create sw transformed buffer */
+
+ igt_copy_fb(display->drm_fd, &input_fb, &sw_transform_fb);
+ igt_assert(igt_cmp_fb_pixels(&input_fb, &sw_transform_fb, 0, 0));
+
+ apply_transforms(colorops, &sw_transform_fb);
+#if DUMP_FBS
+ igt_dump_fb(display, &sw_transform_fb, ".", "sw_transform");
+#endif
+ /* discover and set COLOR PIPELINE */
+
+ /* get COLOR_PIPELINE enum */
+ color_pipeline = get_color_pipeline(display, plane, colorops);
+
+ /* skip test if we can't find applicable pipeline */
+ igt_skip_on(!color_pipeline);
+
+ set_color_pipeline(display, plane, colorops, color_pipeline);
+
+ igt_output_set_writeback_fb(output, &output_fb);
+
+ /* commit COLOR_PIPELINE */
+ igt_display_commit_atomic(display,
+ DRM_MODE_ATOMIC_ALLOW_MODESET,
+ NULL);
+ get_and_wait_out_fence(output);
+#if DUMP_FBS
+ igt_dump_fb(display, &output_fb, ".", "output");
+#endif
+
+ /* compare sw transformed and KMS transformed FBs */
+ igt_assert(compare_with_bracket(&sw_transform_fb, &output_fb));
+
+ /* reset color pipeline*/
+ set_color_pipeline_bypass(plane);
+
+ /* Commit */
+ igt_plane_set_fb(plane, &input_fb);
+ igt_output_set_writeback_fb(output, &output_fb);
+
+ igt_display_commit_atomic(output->display,
+ DRM_MODE_ATOMIC_ALLOW_MODESET,
+ NULL);
+ get_and_wait_out_fence(output);
+
+ /* cleanup */
+ detach_crtc(display, output);
+ igt_remove_fb(display->drm_fd, &input_fb);
+ igt_remove_fb(display->drm_fd, &output_fb);
+}
+
+igt_main
+{
+
+ struct {
+ kms_colorop_t *colorops[MAX_COLOROPS];
+ const char *name;
+ } tests[] = {
+ { { &kms_colorop_srgb_eotf, NULL }, "srgb_eotf" },
+ { { &kms_colorop_srgb_inv_eotf, NULL }, "srgb_inv_eotf" },
+ { { &kms_colorop_srgb_eotf, &kms_colorop_srgb_inv_eotf, NULL }, "srgb_eotf-srgb_inv_eotf" }
+ };
+
+ igt_display_t display;
+ int i;
+
+ igt_fixture {
+ display.drm_fd = drm_open_driver_master(DRIVER_ANY);
+ igt_display_require(&display, display.drm_fd);
+
+ kmstest_set_vt_graphics_mode();
+
+ igt_display_require(&display, display.drm_fd);
+
+ igt_require(display.is_atomic);
+
+ }
+
+ for (i = 0; i < sizeof(tests) / sizeof (tests[0]); i++) {
+ igt_describe("Bla bla bla");
+ igt_subtest_f("plane-%s", tests[i].name)
+ colorop_plane_test(&display, tests[i].colorops);
+ }
+
+ igt_describe("Tests getting and setting COLOR_PIPELINE property on plane");
+#if 0
+ igt_subtest("plane-srgb") {
+ colorop_plane_test(&display, colorops_srgb);
+ }
+ igt_subtest("plane-inv_srgb") {
+ colorop_plane_test(&display, colorops_srgb_inv);
+ }
+#endif
+ igt_fixture {
+
+ igt_display_fini(&display);
+ }
+}
+
diff --git a/tests/meson.build b/tests/meson.build
index a6a8498e2..0ac07c7bb 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -23,6 +23,7 @@ test_progs = [
'kms_bw',
'kms_color',
'kms_concurrent',
+ 'kms_colorop',
'kms_content_protection',
'kms_cursor_crc',
'kms_cursor_edge_walk',
@@ -349,6 +350,7 @@ extra_sources = {
'dumb_buffer': ['dumb_buffer.c' ],
'testdisplay': [ 'testdisplay_hotplug.c' ],
'kms_color': [ 'kms_color_helper.c' ],
+ 'kms_colorop': [ 'kms_color_helper.c' ],
'kms_chamelium_audio': [ join_paths ('chamelium', 'kms_chamelium_helper.c') ],
'kms_chamelium_color': [ 'kms_color_helper.c' ],
'kms_chamelium_edid': [ join_paths ('chamelium', 'kms_chamelium_helper.c') ],
--
2.40.0
More information about the Intel-gfx-trybot
mailing list