[PATCH v3 2/2] tests/kms_sharpness_filter: Add adaptive sharpness filter test
Nautiyal, Ankit K
ankit.k.nautiyal at intel.com
Mon Jul 8 03:40:47 UTC 2024
On 3/28/2023 2:58 PM, Mohammed Thasleem wrote:
> From: Swati Sharma <swati2.sharma at intel.com>
>
> New test is added to validate adaptive sharpness filter on
> LNL platform. Various testcases are added to validate this
> feature. These are non CRC based tests and manual verification
> is required.
>
> Pipe scaler is repurposed to perform a portion of this work.
> This means pipe scaling will be unavailable while the sharpening
> function is being used. The other scaler can be used for plane
> scaler.
>
> 14 subtests are added:
> -basic: verify basic functionality
> -toggle: switch between enable and disable
> -tap: verify different taps selected based on resolution
> -modifiers: verify casf with different modifiers
> -rotation: verify casf with different rotation
> -formats: verify casf with different formats
> -dpms: verify casf with dpms
> -suspend: verify casf with suspend
> -upscale: apply plane scaler and casf together
> -downscale: apply plane scaler and casf together
> -strength: vary strength and check difference in sharpness
> -invalid filter with scaler: enable scaler on 2 planes and attempt
> is made to enable casf
> -invalid filter with plane: enable 2 NV12 planes and attempt
> is made to enable casf
> -invalid plane with filter: enable 1 NV12 plane and casf and attempt
> is made to enable 2nd NV12 plane
>
> TODO: -Enable casf with pipe scaler enabled
> -Enable casf with varying output formats (YCBCR/RGB)
>
> v2: Update modifier type to uint64_t.
> Replace IGT_CRTC_SHARPENESS_STRENGTH with IGT_CRTC_SHARPNESS_STRENGTH.
> v3: Update setup_fb with height and width.
>
> Signed-off-by: Swati Sharma <swati2.sharma at intel.com>
> Signed-off-by: Mohammed Thasleem <mohammed.thasleem at intel.com>
> ---
> tests/intel/kms_sharpness_filter.c | 668 +++++++++++++++++++++++++++++
> tests/meson.build | 1 +
> 2 files changed, 669 insertions(+)
> create mode 100644 tests/intel/kms_sharpness_filter.c
>
> diff --git a/tests/intel/kms_sharpness_filter.c b/tests/intel/kms_sharpness_filter.c
> new file mode 100644
> index 000000000..d592e9a2d
> --- /dev/null
> +++ b/tests/intel/kms_sharpness_filter.c
> @@ -0,0 +1,668 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2024 Intel Corporation
> + */
> +
> +#include "igt.h"
> +#include "igt_kms.h"
> +
> +#define TAP_3 3
> +#define TAP_5 5
> +#define TAP_7 7
> +#define DISABLE_FILTER 0
> +#define MIN_FILTER_STRENGTH 1
> +#define MID_FILTER_STRENGTH 128
> +#define MAX_FILTER_STRENGTH 255
> +#define HDISPLAY_4K 3840
> +#define VDISPLAY_4K 2160
> +#define HDISPLAY_FHD 1920
> +#define VDISPLAY_FHD 1080
> +#define NROUNDS 10
> +
> +/**
> + * TEST: kms sharpness filter
> + * Category: Display
> + * Description: Test to validate content adaptive sharpness filter
> + * Driver requirement: xe
> + * Mega feature: General Display Features
> + * Test category: functionality test
> + * Functionality: casf
> + *
> + * SUBTEST: filter-basic
> + * Description: Verify basic content adaptive sharpness filter.
> + *
> + * SUBTEST: filter-tap
> + * Description: Verify that following a resolution change, distict taps are selected.
> + *
> + * SUBTEST: filter-strength
> + * Description: Verify that varying strength (0-255), affects the degree of sharpeness applied.
> + *
> + * SUBTEST: filter-toggle
> + * Description: Verify toggling between enabling and disabling content adaptive sharpness filter.
> + *
> + * SUBTEST: filter-modifiers
> + * Description: Verify content adaptive sharpness filter with varying modifiers.
> + * Functionality: casf, tiling
> + *
> + * SUBTEST: filter-rotations
> + * Description: Verify content adaptive sharpness filter with varying rotations.
> + * Functionality: casf, rotation
> + *
> + * SUBTEST: filter-formats
> + * Description: Verify content adaptive sharpness filter with varying formats.
> + * Functionality: casf, pixel-format
> + *
> + * SUBTEST: filter-dpms
> + * Description: Verify content adaptive sharpness filter with DPMS.
> + * Functionality: casf, dpms
> + *
> + * SUBTEST: filter-suspend
> + * Description: Verify content adaptive sharpness filter with suspend.
> + * Functionality: casf, suspend
> + *
> + * SUBTEST: filter-scaler-upscale
> + * Description: Verify content adaptive sharpness filter with 1 plane scaler enabled.
> + * Functionality: casf, scaling
> + *
> + * SUBTEST: filter-scaler-downscale
> + * Description: Verify content adaptive sharpness filter with 1 plane scaler enabled.
> + * Functionality: casf, scaling
> + *
> + * SUBTEST: invalid-filter-with-scaler
> + * Description: Negative check for content adaptive sharpness filter
> + * when 2 plane scalers have already been enabled and
> + * attempt is made to enable sharpness filter.
> + * Functionality: casf, scaling
> + *
> + * SUBTEST: invalid-filter-with-plane
> + * Description: Negative check for content adaptive sharpness filter
> + * when 2 NV12 planes have already been enabled and attempt is
> + * made to enable the sharpness filter.
> + * Functionality: casf, plane
> + *
> + * SUBTEST: invalid-plane-with-filter
> + * Description: Negative check for content adaptive sharpness filter
> + * when 1 NV12 plane and sharpness filter have already been enabled
> + * and attempt is made to enable the second NV12 plane.
> + * Functionality: casf, plane
> + */
We need tests where pipe scaler is enabled and we try to enable sharpness.
Need to set the scaling_mode property and try to enable sharpness.
> +
> +IGT_TEST_DESCRIPTION("Test to validate content adaptive sharpness filter");
> +
> +/*
> + * Until the CRC support is added test needs to be invoked with
> + * --interactive|--i to manually verify if "sharpened" image
> + * is seen without corruption for each subtest.
> + */
> +
> +enum test_type {
> + TEST_FILTER_TAP,
> + TEST_FILTER_BASIC,
> + TEST_FILTER_TOGGLE,
> + TEST_FILTER_MODIFIERS,
> + TEST_FILTER_ROTATION,
> + TEST_FILTER_FORMATS,
> + TEST_FILTER_DPMS,
> + TEST_FILTER_SUSPEND,
> + TEST_FILTER_UPSCALE,
> + TEST_FILTER_DOWNSCALE,
> + TEST_FILTER_STRENGTH,
> + TEST_INVALID_FILTER_WITH_SCALER,
> + TEST_INVALID_FILTER_WITH_PLANE,
> + TEST_INVALID_PLANE_WITH_FILTER,
> +};
> +
> +const int filter_strength_list[] = {
> + MIN_FILTER_STRENGTH,
> + (MIN_FILTER_STRENGTH + MID_FILTER_STRENGTH) / 2,
> + MID_FILTER_STRENGTH,
> + (MID_FILTER_STRENGTH + MAX_FILTER_STRENGTH) / 2,
> + MAX_FILTER_STRENGTH,
> +};
> +const int filter_tap_list[] = {
> + TAP_3,
> + TAP_5,
> + TAP_7,
> +};
> +static const struct {
> + uint64_t modifier;
> + const char *name;
> +} modifiers[] = {
> + { DRM_FORMAT_MOD_LINEAR, "linear", },
> + { I915_FORMAT_MOD_X_TILED, "x-tiled", },
> + { I915_FORMAT_MOD_4_TILED, "4-tiled", },
> +};
> +static const int formats[] = {
> + DRM_FORMAT_NV12,
> + DRM_FORMAT_RGB565,
> + DRM_FORMAT_XRGB8888,
> + DRM_FORMAT_XBGR16161616F,
> +};
> +static const igt_rotation_t rotations[] = {
> + IGT_ROTATION_0,
> + IGT_ROTATION_90,
> + IGT_ROTATION_180,
> + IGT_ROTATION_270,
> +};
> +
> +typedef struct {
> + int drm_fd;
> + bool limited;
> + enum pipe pipe_id;
> + struct igt_fb fb[4];
> + igt_pipe_t *pipe;
> + igt_display_t display;
> + igt_output_t *output;
> + igt_plane_t *plane[4];
> + drmModeModeInfo *mode;
> + int filter_strength;
> + int filter_tap;
> + uint64_t modifier;
> + const char *modifier_name;
> + uint32_t format;
> + igt_rotation_t rotation;
> +} data_t;
> +
> +static void set_filter_strength_on_pipe(data_t *data)
> +{
> + igt_pipe_set_prop_value(&data->display, data->pipe_id,
> + IGT_CRTC_SHARPNESS_STRENGTH,
> + data->filter_strength);
> +}
> +
> +static drmModeModeInfo *get_mode(igt_output_t *output, int tap)
> +{
> + drmModeConnector *connector = output->config.connector;
> + drmModeModeInfo *mode = NULL;
> +
> + /*
> + * TAP 3: mode->hdisplay <= 1920 && mode->vdisplay <= 1080
> + * TAP 5: mode->hdisplay > 1920 && mode->vdisplay > 1080
> + * TAP 7: mode->hdisplay >= 3840 && mode->vdisplay >= 2160
> + */
> + switch (tap) {
> + case TAP_3:
> + for (int i = 0; i < connector->count_modes; i++) {
> + if (connector->modes[i].hdisplay <= HDISPLAY_FHD &&
> + connector->modes[i].vdisplay <= VDISPLAY_FHD) {
> + mode = &connector->modes[i];
> + break;
> + }
> + }
> + break;
> + case TAP_5:
> + for (int i = 0; i < connector->count_modes; i++) {
> + if (connector->modes[i].hdisplay > HDISPLAY_FHD &&
> + connector->modes[i].hdisplay < HDISPLAY_4K &&
> + connector->modes[i].vdisplay > VDISPLAY_FHD &&
> + connector->modes[i].vdisplay < VDISPLAY_4K) {
> + mode = &connector->modes[i];
> + break;
> + }
> + }
> + break;
> + case TAP_7:
> + for (int i = 0; i < connector->count_modes; i++) {
> + if (connector->modes[i].hdisplay >= HDISPLAY_4K &&
> + connector->modes[i].vdisplay >= VDISPLAY_4K) {
> + mode = &connector->modes[i];
> + break;
> + }
> + }
> + break;
> + default:
> + igt_assert(0);
> + }
> +
> + return mode;
> +}
> +
> +static void paint_image(igt_fb_t *fb)
> +{
> + cairo_t *cr = igt_get_cairo_ctx(fb->fd, fb);
> + int img_x, img_y, img_w, img_h;
> + const char *file = "1080p-left.png";
> +
> + img_x = img_y = 0;
> + img_w = fb->width;
> + img_h = fb->height;
> +
> + igt_paint_image(cr, file, img_x, img_y, img_w, img_h);
> +
> + igt_put_cairo_ctx(cr);
> +}
> +
> +static void setup_fb(int fd, int width, int height, uint32_t format,
> + uint64_t modifier, struct igt_fb *fb)
> +{
> + int fb_id;
> +
> + fb_id = igt_create_fb(fd, width, height, format, modifier, fb);
> + igt_assert(fb_id);
> +
> + paint_image(fb);
> +}
> +
> +static void cleanup(data_t *data)
> +{
> + for (int i = 0; i < ARRAY_SIZE(data->fb); i++)
> + igt_remove_fb(data->drm_fd, &data->fb[i]);
> +
> + igt_output_set_pipe(data->output, PIPE_NONE);
> + igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +}
> +
> +static void set_planes(data_t *data, enum test_type type)
> +{
> + drmModeModeInfo *mode = data->mode;
> +
> + data->plane[1] = igt_output_get_plane(data->output, 1);
> + data->plane[2] = igt_output_get_plane(data->output, 2);
> +
> + if (type == TEST_FILTER_UPSCALE) {
> + setup_fb(data->drm_fd, 20, 20, data->format, data->modifier, &data->fb[1]);
> + igt_plane_set_fb(data->plane[1], &data->fb[1]);
> + igt_plane_set_size(data->plane[1], mode->hdisplay, mode->vdisplay);
> + }
> +
> + if (type == TEST_FILTER_DOWNSCALE) {
> + setup_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, data->format, data->modifier, &data->fb[1]);
> + igt_plane_set_fb(data->plane[1], &data->fb[1]);
> + igt_plane_set_size(data->plane[1], mode->hdisplay * 0.75, mode->vdisplay * 0.75);
> + }
> +
> + if (type == TEST_INVALID_FILTER_WITH_SCALER) {
> + setup_fb(data->drm_fd, 20, 20, data->format, data->modifier, &data->fb[1]);
> + setup_fb(data->drm_fd, 20, 20, data->format, data->modifier, &data->fb[2]);
> + igt_plane_set_fb(data->plane[1], &data->fb[1]);
> + igt_plane_set_fb(data->plane[2], &data->fb[2]);
> + igt_plane_set_size(data->plane[1], mode->hdisplay, mode->vdisplay);
> + igt_plane_set_size(data->plane[2], mode->hdisplay, mode->vdisplay);
> + }
> +
> + if (type == TEST_INVALID_FILTER_WITH_PLANE) {
> + setup_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, data->format, data->modifier, &data->fb[1]);
> + setup_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, data->format, data->modifier, &data->fb[2]);
> + igt_plane_set_fb(data->plane[1], &data->fb[1]);
> + igt_plane_set_fb(data->plane[2], &data->fb[2]);
> + }
> +
> + if (type == TEST_INVALID_PLANE_WITH_FILTER) {
> + setup_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, data->format, data->modifier, &data->fb[1]);
> + igt_plane_set_fb(data->plane[1], &data->fb[1]);
> + }
> +}
> +
> +static void test_sharpness_filter(data_t *data, enum test_type type)
> +{
> + igt_output_t *output = data->output;
> + drmModeModeInfo *mode = data->mode;
> + int ret;
> + int height = mode->hdisplay;
> + int width = mode->vdisplay;
> +
> + igt_display_reset(&data->display);
> + igt_output_set_pipe(output, data->pipe_id);
> +
> + if (type == TEST_FILTER_TAP) {
> + mode = get_mode(output, data->filter_tap);
> + igt_require(mode != NULL);
> + igt_output_override_mode(output, mode);
> + }
> +
> + data->plane[0] = igt_pipe_get_plane_type(data->pipe, DRM_PLANE_TYPE_PRIMARY);
> + igt_skip_on_f(!igt_plane_has_format_mod(data->plane[0], data->format, data->modifier),
> + "No requested format/modifier on pipe %s\n", kmstest_pipe_name(data->pipe_id));
> +
> + setup_fb(data->drm_fd, height, width, data->format, data->modifier, &data->fb[0]);
> + igt_plane_set_fb(data->plane[0], &data->fb[0]);
> +
> + if (igt_plane_has_rotation(data->plane[0], data->rotation))
> + igt_plane_set_rotation(data->plane[0], data->rotation);
> + else
> + igt_skip("No requested rotation on pipe %s\n", kmstest_pipe_name(data->pipe_id));
> +
> + if (type == TEST_FILTER_UPSCALE ||
> + type == TEST_FILTER_DOWNSCALE ||
> + type == TEST_INVALID_FILTER_WITH_SCALER ||
> + type == TEST_INVALID_FILTER_WITH_PLANE) {
formatting looks off here.
> + set_planes(data, type);
> + }
> +
> + /* Set filter strength property */
> + set_filter_strength_on_pipe(data);
> + igt_debug("Sharpened image should be observed for filter strength > 0\n");
This message should not be displayed for negative test.
Also for the case where we toggle sharpness, we do not expect for
sharpened image.
Regards,
Ankit
> + ret = igt_display_try_commit2(&data->display, COMMIT_ATOMIC);
> +
> + if (type == TEST_FILTER_DPMS) {
> + kmstest_set_connector_dpms(data->drm_fd,
> + output->config.connector,
> + DRM_MODE_DPMS_OFF);
> + kmstest_set_connector_dpms(data->drm_fd,
> + output->config.connector,
> + DRM_MODE_DPMS_ON);
> + }
> +
> + if (type == TEST_FILTER_SUSPEND)
> + igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
> + SUSPEND_TEST_NONE);
> +
> + if (type == TEST_INVALID_PLANE_WITH_FILTER) {
> + data->plane[3] = igt_output_get_plane(data->output, 3);
> + setup_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, data->format, data->modifier, &data->fb[3]);
> + igt_plane_set_fb(data->plane[3], &data->fb[3]);
> +
> + ret = igt_display_try_commit2(&data->display, COMMIT_ATOMIC);
> + }
> +
> + if (type == TEST_INVALID_FILTER_WITH_SCALER ||
> + type == TEST_INVALID_FILTER_WITH_PLANE ||
> + type == TEST_INVALID_PLANE_WITH_FILTER) {
> + igt_assert_eq(ret, -EINVAL);
> + return;
> + } else {
> + igt_assert_eq(ret, 0);
> + }
> +
> + cleanup(data);
> +}
> +
> +static bool has_sharpness_filter(igt_pipe_t *pipe)
> +{
> + return igt_pipe_obj_has_prop(pipe, IGT_CRTC_SHARPNESS_STRENGTH);
> +}
> +
> +static void
> +run_sharpness_filter_test(data_t *data, enum test_type type)
> +{
> + igt_display_t *display = &data->display;
> + igt_output_t *output;
> + enum pipe pipe;
> + char name[40];
> +
> + for_each_pipe_with_valid_output(display, pipe, output) {
> + data->output = output;
> + data->pipe_id = pipe;
> + data->pipe = &display->pipes[data->pipe_id];
> + data->mode = igt_output_get_mode(data->output);
> +
> + if (!has_sharpness_filter(data->pipe))
> + continue;
> +
> + igt_output_set_pipe(output, pipe);
> +
> + if (!intel_pipe_output_combo_valid(display)) {
> + igt_output_set_pipe(output, PIPE_NONE);
> + continue;
> + }
> +
> + switch (type) {
> + case TEST_FILTER_BASIC:
> + snprintf(name, sizeof(name), "-basic");
> + break;
> + case TEST_FILTER_TAP:
> + snprintf(name, sizeof(name), "-tap-%d", data->filter_tap);
> + break;
> + case TEST_FILTER_TOGGLE:
> + snprintf(name, sizeof(name), "-toggle");
> + break;
> + case TEST_FILTER_MODIFIERS:
> + snprintf(name, sizeof(name), "-%s", data->modifier_name);
> + break;
> + case TEST_FILTER_ROTATION:
> + snprintf(name, sizeof(name), "-%srot", igt_plane_rotation_name(data->rotation));
> + break;
> + case TEST_FILTER_FORMATS:
> + snprintf(name, sizeof(name), "-%s", igt_format_str(data->format));
> + break;
> + case TEST_FILTER_DPMS:
> + snprintf(name, sizeof(name), "-dpms");
> + break;
> + case TEST_FILTER_SUSPEND:
> + snprintf(name, sizeof(name), "-suspend");
> + break;
> + case TEST_FILTER_UPSCALE:
> + snprintf(name, sizeof(name), "-upscale");
> + break;
> + case TEST_FILTER_DOWNSCALE:
> + snprintf(name, sizeof(name), "-downscale");
> + break;
> + case TEST_INVALID_FILTER_WITH_SCALER:
> + snprintf(name, sizeof(name), "-invalid-filter-with-scaler");
> + break;
> + case TEST_INVALID_FILTER_WITH_PLANE:
> + snprintf(name, sizeof(name), "-invalid-filter-with-plane");
> + break;
> + case TEST_INVALID_PLANE_WITH_FILTER:
> + snprintf(name, sizeof(name), "-invalid-plane-with-filter");
> + break;
> + case TEST_FILTER_STRENGTH:
> + snprintf(name, sizeof(name), "-strength-%d", data->filter_strength);
> + break;
> + default:
> + igt_assert(0);
> + }
> +
> + igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(data->pipe_id), data->output->name, name)
> + test_sharpness_filter(data, type);
> +
> + if (data->limited)
> + break;
> + }
> +}
> +
> +static int opt_handler(int opt, int opt_index, void *_data)
> +{
> + data_t *data = _data;
> +
> + switch (opt) {
> + case 'l':
> + data->limited = true;
> + break;
> + default:
> + return IGT_OPT_HANDLER_ERROR;
> + }
> +
> + return IGT_OPT_HANDLER_SUCCESS;
> +}
> +
> +static const char help_str[] =
> + " --limited|-l\t\tLimit execution to 1 valid pipe-output combo\n";
> +
> +data_t data = {};
> +
> +igt_main_args("l", NULL, help_str, opt_handler, &data)
> +{
> + igt_fixture {
> + data.drm_fd = drm_open_driver_master(DRIVER_ANY);
> + igt_require(data.drm_fd >= 0);
> +
> + kmstest_set_vt_graphics_mode();
> +
> + igt_display_require(&data.display, data.drm_fd);
> + igt_require(data.display.is_atomic);
> + igt_display_require_output(&data.display);
> + }
> +
> + igt_describe("Verify basic content adaptive sharpness filter.");
> + igt_subtest_with_dynamic("filter-basic") {
> + data.modifier = DRM_FORMAT_MOD_LINEAR;
> + data.rotation = IGT_ROTATION_0;
> + data.format = DRM_FORMAT_XRGB8888;
> + data.filter_strength = MAX_FILTER_STRENGTH;
> +
> + run_sharpness_filter_test(&data, TEST_FILTER_BASIC);
> + }
> +
> + igt_describe("Verify that following a resolution change, "
> + "distict taps are selected.");
> + igt_subtest_with_dynamic("filter-tap") {
> + data.modifier = DRM_FORMAT_MOD_LINEAR;
> + data.rotation = IGT_ROTATION_0;
> + data.format = DRM_FORMAT_XRGB8888;
> + data.filter_strength = MAX_FILTER_STRENGTH;
> +
> + for (int k = 0; k < ARRAY_SIZE(filter_tap_list); k++) {
> + data.filter_tap = filter_tap_list[k];
> +
> + run_sharpness_filter_test(&data, TEST_FILTER_TAP);
> + }
> + }
> +
> + igt_describe("Verify that varying strength(0-255), affects "
> + "the degree of sharpeness applied.");
> + igt_subtest_with_dynamic("filter-strength") {
> + data.modifier = DRM_FORMAT_MOD_LINEAR;
> + data.rotation = IGT_ROTATION_0;
> + data.format = DRM_FORMAT_XRGB8888;
> +
> + for (int k = 0; k < ARRAY_SIZE(filter_strength_list); k++) {
> + data.filter_strength = filter_strength_list[k];
> +
> + run_sharpness_filter_test(&data, TEST_FILTER_STRENGTH);
> + }
> + }
> +
> + igt_describe("Verify toggling between enabling and disabling "
> + "content adaptive sharpness filter.");
> + igt_subtest_with_dynamic("filter-toggle") {
> + data.modifier = DRM_FORMAT_MOD_LINEAR;
> + data.rotation = IGT_ROTATION_0;
> + data.format = DRM_FORMAT_XRGB8888;
> +
> + for (int k = 0; k < NROUNDS; k++) {
> + data.filter_strength = DISABLE_FILTER;
> + run_sharpness_filter_test(&data, TEST_FILTER_TOGGLE);
> + data.filter_strength = MAX_FILTER_STRENGTH;
> + run_sharpness_filter_test(&data, TEST_FILTER_TOGGLE);
> + }
> + }
> +
> + igt_describe("Verify content adaptive sharpness filter with "
> + "varying modifiers.");
> + igt_subtest_with_dynamic("filter-modifiers") {
> + data.rotation = IGT_ROTATION_0;
> + data.format = DRM_FORMAT_XRGB8888;
> + data.filter_strength = MAX_FILTER_STRENGTH;
> +
> + for (int k = 0; k < ARRAY_SIZE(modifiers); k++) {
> + data.modifier = modifiers[k].modifier;
> + data.modifier_name = modifiers[k].name;
> +
> + run_sharpness_filter_test(&data, TEST_FILTER_MODIFIERS);
> + }
> + }
> +
> + igt_describe("Verify content adaptive sharpness filter with "
> + "varying rotations.");
> + igt_subtest_with_dynamic("filter-rotations") {
> + data.modifier = DRM_FORMAT_MOD_LINEAR;
> + data.format = DRM_FORMAT_XRGB8888;
> + data.filter_strength = MAX_FILTER_STRENGTH;
> +
> + for (int k = 0; k < ARRAY_SIZE(rotations); k++) {
> + data.rotation = rotations[k];
> +
> + run_sharpness_filter_test(&data, TEST_FILTER_ROTATION);
> + }
> + }
> +
> + igt_describe("Verify content adaptive sharpness filter with "
> + "varying formats.");
> + igt_subtest_with_dynamic("filter-formats") {
> + data.modifier = DRM_FORMAT_MOD_LINEAR;
> + data.rotation = IGT_ROTATION_0;
> + data.filter_strength = MAX_FILTER_STRENGTH;
> +
> + for (int k = 0; k < ARRAY_SIZE(formats); k++) {
> + data.format = formats[k];
> +
> + run_sharpness_filter_test(&data, TEST_FILTER_FORMATS);
> + }
> + }
> +
> + igt_describe("Verify content adaptive sharpness filter "
> + "with DPMS.");
> + igt_subtest_with_dynamic("filter-dpms") {
> + data.modifier = DRM_FORMAT_MOD_LINEAR;
> + data.rotation = IGT_ROTATION_0;
> + data.format = DRM_FORMAT_XRGB8888;
> + data.filter_strength = MAX_FILTER_STRENGTH;
> +
> + run_sharpness_filter_test(&data, TEST_FILTER_DPMS);
> + }
> +
> + igt_describe("Verify content adaptive sharpness filter "
> + "with suspend.");
> + igt_subtest_with_dynamic("filter-suspend") {
> + data.modifier = DRM_FORMAT_MOD_LINEAR;
> + data.rotation = IGT_ROTATION_0;
> + data.format = DRM_FORMAT_XRGB8888;
> + data.filter_strength = MAX_FILTER_STRENGTH;
> +
> + run_sharpness_filter_test(&data, TEST_FILTER_SUSPEND);
> + }
> +
> + igt_describe("Verify content adaptive sharpness filter "
> + "with 1 plane scaler enabled.");
> + igt_subtest_with_dynamic("filter-scaler-upscale") {
> + data.modifier = DRM_FORMAT_MOD_LINEAR;
> + data.rotation = IGT_ROTATION_0;
> + data.format = DRM_FORMAT_XRGB8888;
> + data.filter_strength = MAX_FILTER_STRENGTH;
> +
> + run_sharpness_filter_test(&data, TEST_FILTER_UPSCALE);
> + }
> +
> + igt_describe("Verify content adaptive sharpness filter "
> + "with 1 plane scaler enabled.");
> + igt_subtest_with_dynamic("filter-scaler-downscale") {
> + data.modifier = DRM_FORMAT_MOD_LINEAR;
> + data.rotation = IGT_ROTATION_0;
> + data.format = DRM_FORMAT_XRGB8888;
> + data.filter_strength = MAX_FILTER_STRENGTH;
> +
> + run_sharpness_filter_test(&data, TEST_FILTER_DOWNSCALE);
> + }
> +
> + igt_describe("Negative check for content adaptive sharpness filter "
> + "when 2 plane scalers have already been enabled and "
> + "attempt is made to enable sharpness filter.");
> + igt_subtest_with_dynamic("invalid-filter-with-scaler") {
> + data.modifier = DRM_FORMAT_MOD_LINEAR;
> + data.rotation = IGT_ROTATION_0;
> + data.format = DRM_FORMAT_XRGB8888;
> + data.filter_strength = MAX_FILTER_STRENGTH;
> +
> + run_sharpness_filter_test(&data, TEST_INVALID_FILTER_WITH_SCALER);
> + }
> +
> + igt_describe("Negative check for content adaptive sharpness filter "
> + "when 2 NV12 planes have already been enabled and attempt is "
> + "made to enable the sharpness filter.");
> + igt_subtest_with_dynamic("invalid-filter-with-plane") {
> + data.modifier = DRM_FORMAT_MOD_LINEAR;
> + data.rotation = IGT_ROTATION_0;
> + data.format = DRM_FORMAT_NV12;
> + data.filter_strength = MAX_FILTER_STRENGTH;
> +
> + run_sharpness_filter_test(&data, TEST_INVALID_FILTER_WITH_PLANE);
> + }
> +
> + igt_describe("Negative check for content adaptive sharpness filter "
> + "when 1 NV12 plane and sharpness filter have already been enabled "
> + "and attempt is made to enable the second NV12 plane.");
> + igt_subtest_with_dynamic("invalid-plane-with-filter") {
> + data.modifier = DRM_FORMAT_MOD_LINEAR;
> + data.rotation = IGT_ROTATION_0;
> + data.format = DRM_FORMAT_NV12;
> + data.filter_strength = MAX_FILTER_STRENGTH;
> +
> + run_sharpness_filter_test(&data, TEST_INVALID_PLANE_WITH_FILTER);
> + }
> +
> + igt_fixture {
> + igt_display_fini(&data.display);
> + close(data.drm_fd);
> + }
> +}
> diff --git a/tests/meson.build b/tests/meson.build
> index 758ae090c..744551bcb 100644
> --- a/tests/meson.build
> +++ b/tests/meson.build
> @@ -271,6 +271,7 @@ intel_kms_progs = [
> 'kms_psr2_su',
> 'kms_psr_stress_test',
> 'kms_pwrite_crc',
> + 'kms_sharpness_filter',
> ]
>
> intel_xe_progs = [
More information about the igt-dev
mailing list