[igt-dev] [PATCH i-g-t 3/3] tests/kms_nv12: Add nv12 specific tests.
Maarten Lankhorst
maarten.lankhorst at linux.intel.com
Tue Jul 24 13:59:27 UTC 2018
Add tests excercising switching between various scaled/unscaled
transitions to and from NV12, since some of the workarounds mention
this may fail.
We also add NV12 specific clipping/scaling tests, to make sure
that NV12 src coordinates are always programmed as a multiple of 4
correctly, and verify scaling/clipping works with CRC tests.
Signed-off-by: Maarten Lankhorst <maarten.lankhorst at linux.intel.com>
---
tests/Makefile.sources | 1 +
tests/kms_nv12.c | 743 +++++++++++++++++++++++++++++++++++++++++
tests/meson.build | 1 +
3 files changed, 745 insertions(+)
create mode 100644 tests/kms_nv12.c
diff --git a/tests/Makefile.sources b/tests/Makefile.sources
index c84933f1d971..dab9260f584d 100644
--- a/tests/Makefile.sources
+++ b/tests/Makefile.sources
@@ -190,6 +190,7 @@ TESTS_progs = \
kms_invalid_dotclock \
kms_legacy_colorkey \
kms_mmap_write_crc \
+ kms_nv12 \
kms_panel_fitting \
kms_pipe_b_c_ivb \
kms_pipe_crc_basic \
diff --git a/tests/kms_nv12.c b/tests/kms_nv12.c
new file mode 100644
index 000000000000..05ae83e53dda
--- /dev/null
+++ b/tests/kms_nv12.c
@@ -0,0 +1,743 @@
+/*
+ * 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
+ * AUTHORS OR COPYRIGHT HOLDERS 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.
+ *
+ * Authors:
+ * Maarten Lankhorst <maarten.lankhorst at linux.intel.com>
+ */
+#include "config.h"
+
+#include "igt.h"
+#include <cairo.h>
+#include <errno.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+typedef struct {
+ igt_display_t display;
+
+ igt_pipe_crc_t *pipe_crc;
+ struct igt_fb fb[4];
+} data_t;
+
+static bool plane_supports_format(igt_plane_t *plane, uint32_t format)
+{
+ int i;
+
+ if (!igt_fb_supported_format(format))
+ return false;
+
+ for (i = 0; i < plane->drm_plane->count_formats; i++)
+ if (plane->drm_plane->formats[i] == format)
+ return true;
+
+ return false;
+}
+
+static bool pipe_supports_format(igt_display_t *display, enum pipe pipe, uint32_t format)
+{
+ igt_plane_t *plane;
+
+ for_each_plane_on_pipe(display, pipe, plane)
+ if (plane_supports_format(plane, format))
+ return true;
+
+ return false;
+}
+
+static void remove_fbs(data_t *data)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(data->fb); i++)
+ igt_remove_fb(data->display.drm_fd, &data->fb[i]);
+}
+
+static void prepare_crtc(data_t *data, enum pipe pipe, igt_output_t *output)
+{
+ igt_display_t *display = &data->display;
+
+ remove_fbs(data);
+ igt_display_reset(display);
+ igt_output_set_pipe(output, pipe);
+ igt_display_commit2(display, COMMIT_ATOMIC);
+
+ igt_pipe_crc_free(data->pipe_crc);
+ data->pipe_crc = igt_pipe_crc_new(display->drm_fd, pipe, INTEL_PIPE_CRC_SOURCE_AUTO);
+}
+
+static void set_fb(igt_plane_t *plane, struct igt_fb *fb, bool scaled)
+{
+ igt_plane_set_fb(plane, fb);
+
+ if (scaled && fb)
+ igt_fb_set_size(fb, plane, fb->width, 16);
+
+ if (fb && fb->tiling == LOCAL_I915_FORMAT_MOD_Y_TILED) {
+ igt_plane_set_rotation(plane, IGT_ROTATION_90);
+ igt_plane_set_size(plane, fb->height, fb->width);
+ } else
+ igt_plane_set_rotation(plane, IGT_ROTATION_0);
+}
+
+static void nv12_rgb_switch(data_t *data, enum pipe pipe, igt_output_t *output, bool scaled, unsigned format)
+{
+ drmModeModeInfo *mode = igt_output_get_mode(output);
+ igt_display_t *display = &data->display;
+ igt_plane_t *plane;
+ int i;
+ igt_crc_t ref_crc[4], crc;
+
+ prepare_crtc(data, pipe, output);
+
+ igt_create_pattern_fb(display->drm_fd, mode->hdisplay, mode->vdisplay,
+ format, LOCAL_I915_FORMAT_MOD_X_TILED,
+ &data->fb[0]);
+
+ igt_create_pattern_fb(display->drm_fd, mode->vdisplay, mode->hdisplay,
+ format, LOCAL_I915_FORMAT_MOD_Y_TILED,
+ &data->fb[1]);
+
+ igt_create_pattern_fb(display->drm_fd, mode->hdisplay, mode->vdisplay,
+ DRM_FORMAT_XRGB8888, LOCAL_I915_FORMAT_MOD_X_TILED,
+ &data->fb[2]);
+
+ igt_create_pattern_fb(display->drm_fd, mode->vdisplay, mode->hdisplay,
+ DRM_FORMAT_XRGB8888, LOCAL_I915_FORMAT_MOD_Y_TILED,
+ &data->fb[3]);
+
+ for_each_plane_on_pipe(display, pipe, plane) {
+ if (!plane_supports_format(plane, DRM_FORMAT_XRGB8888))
+ continue;
+
+ /* We only have few scalers, don't use 1 for unused planes */
+ if (plane->type != DRM_PLANE_TYPE_CURSOR && !scaled)
+ set_fb(plane, &data->fb[3], false);
+ }
+
+ for_each_plane_on_pipe(display, pipe, plane) {
+ const int seq[] = {
+ 2, 0, 2, 1, 3, 1, 3
+ };
+
+ if (!plane_supports_format(plane, format))
+ continue;
+
+ /* Collect reference crc with toggle in between. */
+ for (i = 0; i < ARRAY_SIZE(ref_crc); i++) {
+ set_fb(plane, &data->fb[i], scaled);
+ igt_display_commit2(display, COMMIT_ATOMIC);
+
+ igt_pipe_crc_collect_crc(data->pipe_crc, &ref_crc[i]);
+
+ set_fb(plane, NULL, scaled);
+ igt_display_commit2(display, COMMIT_ATOMIC);
+ }
+
+ for (i = 0; i < ARRAY_SIZE(seq); i++) {
+ int j = seq[i];
+
+ set_fb(plane, &data->fb[j], scaled);
+ igt_display_commit2(display, COMMIT_ATOMIC);
+
+ igt_pipe_crc_collect_crc(data->pipe_crc, &crc);
+ igt_assert_crc_equal(&ref_crc[j], &crc);
+ }
+
+ /* We only have few scalers, don't use 1 for unused planes */
+ if (scaled)
+ igt_plane_set_fb(plane, NULL);
+ }
+}
+
+#define assert_collected_crc_equal(pipe_crc, crc, ref_crc, rotation) \
+ do { \
+ igt_pipe_crc_get_current(display->drm_fd, pipe_crc, crc); \
+ igt_warn_on_f(!igt_check_crc_equal(ref_crc, crc), "mismatch with %x rotation!\n", rotation); \
+ } while (0)
+
+static void set_src_coords(igt_plane_t *plane, struct igt_fb *fb,
+ igt_rotation_t rot, int vis, int hidden)
+{
+ switch (rot) {
+ case IGT_ROTATION_0:
+ igt_fb_set_position(fb, plane, fb->width / 2 - vis, fb->height / 2 - vis);
+ break;
+ case IGT_ROTATION_90:
+ igt_fb_set_position(fb, plane, fb->width / 2 - hidden, fb->height / 2 - vis);
+ break;
+ case IGT_ROTATION_180:
+ igt_fb_set_position(fb, plane, fb->width / 2 - hidden, fb->height / 2 - hidden);
+ break;
+ case IGT_ROTATION_270:
+ igt_fb_set_position(fb, plane, fb->width / 2 - vis, fb->height / 2 - hidden);
+ break;
+ default: igt_assert(0);
+ }
+ igt_fb_set_size(fb, plane, vis + hidden, vis + hidden);
+}
+
+static void nv12_valid_width_plane(data_t *data, drmModeModeInfo *mode,
+ igt_plane_t *plane, struct igt_fb *fb,
+ igt_rotation_t rot, igt_crc_t *ref_crc)
+{
+ igt_display_t *display = &data->display;
+ igt_crc_t crc;
+ struct igt_fb *clip_fb = &data->fb[2];
+ int i;
+
+ igt_plane_set_fb(plane, fb);
+ igt_plane_set_rotation(plane, rot);
+ if (rot & (IGT_ROTATION_90 | IGT_ROTATION_270))
+ igt_plane_set_size(plane, fb->height, fb->width);
+ igt_display_commit2(display, COMMIT_ATOMIC);
+
+ /* Just clipping.. */
+ igt_plane_set_fb(plane, clip_fb);
+ if (rot & (IGT_ROTATION_90 | IGT_ROTATION_270))
+ igt_plane_set_size(plane, clip_fb->height, clip_fb->width);
+ igt_plane_set_position(plane, mode->hdisplay - clip_fb->width / 2, mode->vdisplay - clip_fb->height / 2);
+ igt_display_commit2(display, COMMIT_ATOMIC);
+ assert_collected_crc_equal(data->pipe_crc, &crc, ref_crc, rot);
+
+ /* Clipping and scaling. */
+ igt_fb_set_position(clip_fb, plane, clip_fb->width / 2 - 16, clip_fb->height / 2 - 16);
+ igt_fb_set_size(clip_fb, plane, 32, 32);
+ igt_display_commit2(display, COMMIT_ATOMIC);
+ assert_collected_crc_equal(data->pipe_crc, &crc, ref_crc, rot);
+
+ /* Invalid < 16 src visible. */
+ set_src_coords(plane, clip_fb, rot, 8, 8);
+ igt_assert_eq(igt_display_try_commit2(display, COMMIT_ATOMIC), -EINVAL);
+
+ /* Try different alignments for x/y to see if any hit underruns */
+ for (i = 1; i < 4; i++) {
+ set_src_coords(plane, clip_fb, rot, 16 + 2 * i, 16 - 2 * i);
+ igt_display_commit2(display, COMMIT_ATOMIC);
+ assert_collected_crc_equal(data->pipe_crc, &crc, ref_crc, rot);
+
+ /* And also show more of the screen */
+ set_src_coords(plane, clip_fb, rot, 16 + i, 16 + i);
+ if (rot == IGT_ROTATION_270 || rot == (IGT_ROTATION_90 | IGT_REFLECT_X)) {
+ igt_assert_eq(igt_display_try_commit2(display, COMMIT_ATOMIC), -EINVAL);
+ continue;
+ }
+ igt_display_commit2(display, COMMIT_ATOMIC);
+ assert_collected_crc_equal(data->pipe_crc, &crc, ref_crc, rot);
+ }
+
+ /*
+ * As a final test, try with 16 src visible, and various invisible
+ * components to check clipping doesn't drop the visible src below 16.
+ */
+ for (i = 0; i < 16; i += 4) {
+ set_src_coords(plane, clip_fb, rot, 16, i);
+ if (rot & (IGT_ROTATION_90 | IGT_ROTATION_270))
+ igt_plane_set_size(plane, (clip_fb->height / 32) * (16 + i),
+ (clip_fb->width / 32) * (16 + i));
+ else
+ igt_plane_set_size(plane, (clip_fb->width / 32) * (16 + i),
+ (clip_fb->height / 32) * (16 + i));
+ igt_display_commit2(display, COMMIT_ATOMIC);
+ assert_collected_crc_equal(data->pipe_crc, &crc, ref_crc, rot);
+ }
+}
+
+static void nv12_valid_width(data_t *data, enum pipe pipe, igt_output_t *output, unsigned format)
+{
+ drmModeModeInfo *mode = igt_output_get_mode(output);
+ igt_display_t *display = &data->display;
+ igt_plane_t *plane;
+ struct igt_fb *clip_fb = &data->fb[2];
+ struct igt_fb *ref_fb = &data->fb[3];
+
+ prepare_crtc(data, pipe, output);
+
+ igt_create_pattern_fb(display->drm_fd, mode->hdisplay, mode->vdisplay,
+ format, LOCAL_I915_FORMAT_MOD_X_TILED,
+ &data->fb[0]);
+
+ igt_create_pattern_fb(display->drm_fd, mode->vdisplay, mode->hdisplay,
+ format, LOCAL_I915_FORMAT_MOD_Y_TILED,
+ &data->fb[1]);
+
+ igt_create_fb(display->drm_fd, 64, 64, format,
+ LOCAL_I915_FORMAT_MOD_Y_TILED, ref_fb);
+
+ igt_create_fb(display->drm_fd, 2 * ref_fb->width,
+ 2 * ref_fb->height, format,
+ LOCAL_I915_FORMAT_MOD_Y_TILED, clip_fb);
+
+ igt_pipe_crc_start(data->pipe_crc);
+
+ for_each_plane_on_pipe(display, pipe, plane) {
+ igt_crc_t ref_crc[4];
+ cairo_t *cr;
+ static const double colors[4][3] = {
+ { 1., 0., 0. },
+ { 0., 1., 0. },
+ { 0., 0., 1. },
+ { 1., 1., 1. }
+ };
+ int i;
+
+ if (!plane_supports_format(plane, format))
+ continue;
+
+ /* Draw the FB that will be used for clipping tests. */
+ cr = igt_get_cairo_ctx(display->drm_fd, clip_fb);
+ igt_paint_color(cr, 0, 0, clip_fb->width / 2, clip_fb->height / 2,
+ colors[0][0], colors[0][1], colors[0][2]);
+
+ igt_paint_color(cr, clip_fb->width / 2, 0,
+ clip_fb->width / 2, clip_fb->height / 2,
+ colors[1][0], colors[1][1], colors[1][2]);
+
+ igt_paint_color(cr, clip_fb->width / 2, clip_fb->height / 2,
+ clip_fb->width / 2, clip_fb->height / 2,
+ colors[2][0], colors[2][1], colors[2][2]);
+
+ igt_paint_color(cr, 0, clip_fb->height / 2,
+ clip_fb->width / 2, clip_fb->height / 2,
+ colors[3][0], colors[3][1], colors[3][2]);
+
+ igt_put_cairo_ctx(display->drm_fd, clip_fb, cr);
+
+ /* Draw all reference FB's to collect the CRC. */
+ for (i = 0; i < 4; i++) {
+ cr = igt_get_cairo_ctx(display->drm_fd, ref_fb);
+ igt_paint_color(cr, 0, 0, ref_fb->width, ref_fb->height,
+ colors[i][0], colors[i][1], colors[i][2]);
+ igt_put_cairo_ctx(display->drm_fd, &data->fb[3], cr);
+
+ if (!i) {
+ igt_plane_set_fb(plane, ref_fb);
+ igt_plane_set_position(plane, mode->hdisplay - ref_fb->width, mode->vdisplay - ref_fb->height);
+ igt_display_commit2(display, COMMIT_ATOMIC);
+ } else {
+ igt_dirty_fb(display->drm_fd, ref_fb);
+ igt_wait_for_vblank(display->drm_fd, pipe);
+ }
+
+ igt_pipe_crc_drain(data->pipe_crc);
+ igt_pipe_crc_get_single(data->pipe_crc, &ref_crc[i]);
+ }
+
+ igt_plane_set_fb(plane, NULL);
+ igt_plane_set_position(plane, 0, 0);
+
+ nv12_valid_width_plane(data, mode, plane, &data->fb[0], IGT_ROTATION_0, &ref_crc[0]);
+ nv12_valid_width_plane(data, mode, plane, &data->fb[1], IGT_ROTATION_90, &ref_crc[1]);
+ nv12_valid_width_plane(data, mode, plane, &data->fb[0], IGT_ROTATION_180, &ref_crc[2]);
+ nv12_valid_width_plane(data, mode, plane, &data->fb[1], IGT_ROTATION_270, &ref_crc[3]);
+
+ igt_plane_set_fb(plane, NULL);
+ }
+}
+
+static bool nv12_commit_rotated(igt_display_t *display, igt_rotation_t rot)
+{
+ if (igt_display_try_commit2(display, COMMIT_ATOMIC) < 0) {
+ igt_assert(rot == IGT_ROTATION_270 || rot == (IGT_ROTATION_90 | IGT_REFLECT_X));
+ igt_debug("Skipping rotated test, alignment is wrong.\n");
+ return false;
+ }
+
+ return true;
+}
+
+static void nv12_crop_scale_bug_plane(data_t *data, drmModeModeInfo *mode,
+ igt_plane_t *plane, struct igt_fb *fb,
+ igt_rotation_t rot, igt_crc_t *ref_crc)
+{
+ igt_display_t *display = &data->display;
+ igt_crc_t crc;
+
+ igt_plane_set_fb(plane, fb);
+ igt_plane_set_rotation(plane, rot);
+ igt_fb_set_position(fb, plane, fb->width / 4 + 1, fb->height / 4 + 1);
+ igt_fb_set_size(fb, plane, fb->width / 2 + 2, fb->height / 2 + 2);
+
+ igt_plane_set_position(plane, 64, 64);
+ igt_plane_set_size(plane, 256, 256);
+
+ if (nv12_commit_rotated(display, rot))
+ assert_collected_crc_equal(data->pipe_crc, &crc, ref_crc, rot);
+}
+
+static void nv12_crop_scale_bug(data_t *data, enum pipe pipe, igt_output_t *output, unsigned format)
+{
+ drmModeModeInfo *mode = igt_output_get_mode(output);
+ igt_display_t *display = &data->display;
+ igt_plane_t *plane;
+ struct igt_fb *clip_fb = &data->fb[2];
+ struct igt_fb *ref_fb = &data->fb[3];
+
+ prepare_crtc(data, pipe, output);
+
+ igt_create_pattern_fb(display->drm_fd, mode->hdisplay, mode->vdisplay,
+ format, LOCAL_I915_FORMAT_MOD_X_TILED, &data->fb[0]);
+
+ igt_create_pattern_fb(display->drm_fd, mode->vdisplay, mode->hdisplay,
+ format, LOCAL_I915_FORMAT_MOD_Y_TILED, &data->fb[1]);
+
+ igt_create_color_fb(display->drm_fd, 256, 256, format,
+ LOCAL_I915_FORMAT_MOD_Y_TILED, 1., 1., 1., ref_fb);
+
+ igt_create_fb(display->drm_fd, 80, 128, format,
+ LOCAL_I915_FORMAT_MOD_Y_TILED, clip_fb);
+
+ igt_pipe_crc_start(data->pipe_crc);
+
+ for_each_plane_on_pipe(display, pipe, plane) {
+ igt_crc_t ref_crc;
+ cairo_t *cr;
+
+ if (!plane_supports_format(plane, format))
+ continue;
+
+ /* Draw the FB that will be used for clipping tests. */
+ cr = igt_get_cairo_ctx(display->drm_fd, clip_fb);
+ igt_paint_color(cr, 0, 0, clip_fb->width, clip_fb->height, .5, .5, .5);
+
+ igt_paint_color(cr, clip_fb->width / 4, clip_fb->height / 4,
+ clip_fb->width / 2, clip_fb->height / 2, 1., 1., 1.);
+
+ igt_put_cairo_ctx(display->drm_fd, clip_fb, cr);
+
+ igt_plane_set_fb(plane, ref_fb);
+ igt_plane_set_position(plane, 64, 64);
+ igt_display_commit2(display, COMMIT_ATOMIC);
+
+ igt_pipe_crc_drain(data->pipe_crc);
+ igt_pipe_crc_get_single(data->pipe_crc, &ref_crc);
+
+ nv12_crop_scale_bug_plane(data, mode, plane, clip_fb, IGT_ROTATION_0, &ref_crc);
+ nv12_crop_scale_bug_plane(data, mode, plane, clip_fb, IGT_ROTATION_90, &ref_crc);
+ nv12_crop_scale_bug_plane(data, mode, plane, clip_fb, IGT_ROTATION_180, &ref_crc);
+ nv12_crop_scale_bug_plane(data, mode, plane, clip_fb, IGT_ROTATION_270, &ref_crc);
+
+ igt_plane_set_fb(plane, NULL);
+ }
+}
+
+static void nv12_chroma_subpixel_clip_plane_with_cursor(data_t *data,
+ igt_plane_t *plane,
+ struct igt_fb *clip_fb,
+ igt_plane_t *cursor,
+ struct igt_fb *cursor_fb,
+ igt_crc_t *ref_crc,
+ int cursor_x, int cursor_y)
+{
+ igt_display_t *display = &data->display;
+
+ igt_plane_set_fb(plane, clip_fb);
+ igt_plane_set_position(plane, 64, 64);
+ igt_plane_set_rotation(plane, IGT_ROTATION_0);
+
+ igt_plane_set_fb(cursor, cursor_fb);
+ igt_plane_set_position(cursor, cursor_x, cursor_y);
+ igt_display_commit2(display, COMMIT_ATOMIC);
+
+ igt_pipe_crc_drain(data->pipe_crc);
+ igt_pipe_crc_get_single(data->pipe_crc, ref_crc);
+
+ igt_plane_set_fb(cursor, NULL);
+}
+
+static void nv12_chroma_subpixel_clip_plane_right(data_t *data,
+ igt_rotation_t rotation,
+ igt_plane_t *plane,
+ struct igt_fb *clip_fb,
+ igt_crc_t *ref_crc)
+{
+ igt_display_t *display = &data->display;
+ igt_crc_t crc = {};
+
+ igt_plane_set_fb(plane, clip_fb);
+ igt_plane_set_position(plane, 64, 64);
+ igt_plane_set_rotation(plane, rotation);
+ igt_plane_set_size(plane, clip_fb->width - 1, clip_fb->height);
+
+ switch (rotation) {
+ case IGT_ROTATION_180:
+ igt_fb_set_position(clip_fb, plane, 1, 0);
+ case IGT_ROTATION_0:
+ igt_fb_set_size(clip_fb, plane, clip_fb->width - 1, clip_fb->height);
+ break;
+
+ case IGT_ROTATION_270:
+ igt_fb_set_position(clip_fb, plane, 0, 1);
+ case IGT_ROTATION_90:
+ igt_fb_set_size(clip_fb, plane, clip_fb->width, clip_fb->height - 1);
+ break;
+ default:
+ igt_assert_f(0, "Unhandled rotation %x\n", rotation);
+ }
+
+ igt_display_commit2(display, COMMIT_ATOMIC);
+ assert_collected_crc_equal(data->pipe_crc, &crc, ref_crc, rotation);
+}
+
+static void nv12_chroma_subpixel_clip_plane_bottom(data_t *data,
+ igt_rotation_t rotation,
+ igt_plane_t *plane,
+ struct igt_fb *clip_fb,
+ igt_crc_t *ref_crc)
+{
+ igt_display_t *display = &data->display;
+ igt_crc_t crc = {};
+
+ igt_plane_set_fb(plane, clip_fb);
+ igt_plane_set_position(plane, 64, 64);
+ igt_plane_set_rotation(plane, rotation);
+ igt_plane_set_size(plane, clip_fb->width, clip_fb->height - 1);
+
+ switch (rotation) {
+ case IGT_ROTATION_180:
+ igt_fb_set_position(clip_fb, plane, 0, 1);
+ case IGT_ROTATION_0:
+ igt_fb_set_size(clip_fb, plane, clip_fb->width, clip_fb->height - 1);
+ break;
+
+ case IGT_ROTATION_270:
+ igt_fb_set_position(clip_fb, plane, 1, 0);
+ case IGT_ROTATION_90:
+ igt_fb_set_size(clip_fb, plane, clip_fb->width - 1, clip_fb->height);
+ break;
+ default:
+ igt_assert_f(0, "Unhandled rotation %x\n", rotation);
+ }
+
+ if (nv12_commit_rotated(display, rotation))
+ assert_collected_crc_equal(data->pipe_crc, &crc, ref_crc, rotation);
+}
+
+static void nv12_chroma_subpixel_clip_plane_left(data_t *data,
+ igt_rotation_t rotation,
+ igt_plane_t *plane,
+ struct igt_fb *clip_fb,
+ igt_crc_t *ref_crc)
+{
+ igt_display_t *display = &data->display;
+ igt_crc_t crc = {};
+
+ igt_plane_set_fb(plane, clip_fb);
+ igt_plane_set_position(plane, 65, 64);
+ igt_plane_set_rotation(plane, rotation);
+ igt_plane_set_size(plane, clip_fb->width - 1, clip_fb->height);
+
+ switch (rotation) {
+ case IGT_ROTATION_0:
+ igt_fb_set_position(clip_fb, plane, 1, 0);
+ case IGT_ROTATION_180:
+ igt_fb_set_size(clip_fb, plane, clip_fb->width - 1, clip_fb->height);
+ break;
+
+ case IGT_ROTATION_90:
+ igt_fb_set_position(clip_fb, plane, 0, 1);
+ case IGT_ROTATION_270:
+ igt_fb_set_size(clip_fb, plane, clip_fb->width, clip_fb->height - 1);
+ break;
+ default:
+ igt_assert_f(0, "Unhandled rotation %x\n", rotation);
+ }
+
+ igt_display_commit2(display, COMMIT_ATOMIC);
+ assert_collected_crc_equal(data->pipe_crc, &crc, ref_crc, rotation);
+}
+
+
+static void nv12_chroma_subpixel_clip_plane_top(data_t *data,
+ igt_rotation_t rotation,
+ igt_plane_t *plane,
+ struct igt_fb *clip_fb,
+ igt_crc_t *ref_crc)
+{
+ igt_display_t *display = &data->display;
+ igt_crc_t crc = {};
+
+ igt_plane_set_fb(plane, clip_fb);
+ igt_plane_set_position(plane, 64, 65);
+ igt_plane_set_rotation(plane, rotation);
+ igt_plane_set_size(plane, clip_fb->width, clip_fb->height - 1);
+
+ switch (rotation) {
+ case IGT_ROTATION_0:
+ igt_fb_set_position(clip_fb, plane, 0, 1);
+ case IGT_ROTATION_180:
+ igt_fb_set_size(clip_fb, plane, clip_fb->width, clip_fb->height - 1);
+ break;
+
+ case IGT_ROTATION_90:
+ igt_fb_set_position(clip_fb, plane, 1, 0);
+ case IGT_ROTATION_270:
+ igt_fb_set_size(clip_fb, plane, clip_fb->width - 1, clip_fb->height);
+ break;
+ default:
+ igt_assert_f(0, "Unhandled rotation %x\n", rotation);
+ }
+
+ if (nv12_commit_rotated(display, rotation))
+ assert_collected_crc_equal(data->pipe_crc, &crc, ref_crc, rotation);
+}
+
+static void nv12_chroma_subpixel_clip(data_t *data, enum pipe pipe, igt_output_t *output, unsigned format)
+{
+ drmModeModeInfo *mode = igt_output_get_mode(output);
+ igt_display_t *display = &data->display;
+ igt_pipe_t *pipe_obj = &display->pipes[pipe];
+ struct igt_fb *bg_fb = &data->fb[0];
+ struct igt_fb *bg_cursor_fb = &data->fb[1];
+ struct igt_fb *black_cursor_fb = &data->fb[2];
+ struct igt_fb *clip_fb = &data->fb[3];
+ igt_plane_t *primary = igt_pipe_get_plane_type(pipe_obj, DRM_PLANE_TYPE_PRIMARY);
+ igt_plane_t *cursor = igt_pipe_get_plane_type(pipe_obj, DRM_PLANE_TYPE_CURSOR);
+ igt_plane_t *plane;
+ cairo_t *cr;
+
+ prepare_crtc(data, pipe, output);
+
+ igt_create_color_fb(display->drm_fd, mode->hdisplay, mode->vdisplay,
+ DRM_FORMAT_XRGB8888, LOCAL_I915_FORMAT_MOD_X_TILED,
+ .0, .0, 1., bg_fb);
+
+ igt_create_color_fb(display->drm_fd, 256, 256,
+ DRM_FORMAT_ARGB8888, LOCAL_DRM_FORMAT_MOD_NONE,
+ .0, .0, 1., bg_cursor_fb);
+
+ igt_create_color_fb(display->drm_fd, 256, 256,
+ DRM_FORMAT_ARGB8888, LOCAL_DRM_FORMAT_MOD_NONE,
+ .0, .0, .0, black_cursor_fb);
+
+ igt_create_fb(display->drm_fd, 256, 256,
+ format, LOCAL_I915_FORMAT_MOD_Y_TILED, clip_fb);
+
+ /* Draw the FB that will be used for clipping the chroma subpixel test. */
+ cr = igt_get_cairo_ctx(display->drm_fd, clip_fb);
+
+ igt_paint_color(cr, 0, 0, clip_fb->width, clip_fb->height, 1., 0., 0.);
+ igt_paint_color(cr, 2, 2, clip_fb->width - 4, clip_fb->height - 4, 0., 1., 1.);
+ igt_paint_color(cr, 4, 4, clip_fb->width - 8, clip_fb->height - 8, .75, .75, 1.);
+
+ /* White dots in the corners. */
+ igt_paint_color(cr, 0, 0, 6, 6, 1., 1., 1.);
+ igt_paint_color(cr, clip_fb->width - 6, 0, 6, 6, 1., 1., 1.);
+ igt_paint_color(cr, 0, clip_fb->height - 6, 6, 6, 1., 1., 1.);
+ igt_paint_color(cr, clip_fb->width - 6, clip_fb->height - 6, 6, 6, 1., 1., 1.);
+
+ igt_put_cairo_ctx(display->drm_fd, clip_fb, cr);
+
+ igt_pipe_crc_start(data->pipe_crc);
+
+ igt_plane_set_fb(primary, bg_fb);
+ for_each_plane_on_pipe(display, pipe, plane) {
+ struct igt_fb *cursor_fb = plane == primary ? black_cursor_fb : bg_cursor_fb;
+ igt_crc_t ref_crc;
+
+ if (!plane_supports_format(plane, format) || plane == cursor)
+ continue;
+
+ nv12_chroma_subpixel_clip_plane_with_cursor(data, plane, clip_fb, cursor, cursor_fb, &ref_crc, 63 + clip_fb->width, 64);
+ nv12_chroma_subpixel_clip_plane_right(data, IGT_ROTATION_0, plane, clip_fb, &ref_crc);
+ nv12_chroma_subpixel_clip_plane_right(data, IGT_ROTATION_90, plane, clip_fb, &ref_crc);
+ nv12_chroma_subpixel_clip_plane_right(data, IGT_ROTATION_180, plane, clip_fb, &ref_crc);
+ nv12_chroma_subpixel_clip_plane_right(data, IGT_ROTATION_270, plane, clip_fb, &ref_crc);
+
+ nv12_chroma_subpixel_clip_plane_with_cursor(data, plane, clip_fb, cursor, cursor_fb, &ref_crc, 64, 63 + clip_fb->height);
+ nv12_chroma_subpixel_clip_plane_bottom(data, IGT_ROTATION_0, plane, clip_fb, &ref_crc);
+ nv12_chroma_subpixel_clip_plane_bottom(data, IGT_ROTATION_90, plane, clip_fb, &ref_crc);
+ nv12_chroma_subpixel_clip_plane_bottom(data, IGT_ROTATION_180, plane, clip_fb, &ref_crc);
+ nv12_chroma_subpixel_clip_plane_bottom(data, IGT_ROTATION_270, plane, clip_fb, &ref_crc);
+
+ nv12_chroma_subpixel_clip_plane_with_cursor(data, plane, clip_fb, cursor, cursor_fb, &ref_crc, 65 - cursor_fb->width, 64);
+ nv12_chroma_subpixel_clip_plane_left(data, IGT_ROTATION_0, plane, clip_fb, &ref_crc);
+ nv12_chroma_subpixel_clip_plane_left(data, IGT_ROTATION_90, plane, clip_fb, &ref_crc);
+ nv12_chroma_subpixel_clip_plane_left(data, IGT_ROTATION_180, plane, clip_fb, &ref_crc);
+ nv12_chroma_subpixel_clip_plane_left(data, IGT_ROTATION_270, plane, clip_fb, &ref_crc);
+
+ nv12_chroma_subpixel_clip_plane_with_cursor(data, plane, clip_fb, cursor, cursor_fb, &ref_crc, 64, 65 - cursor_fb->height);
+ nv12_chroma_subpixel_clip_plane_top(data, IGT_ROTATION_0, plane, clip_fb, &ref_crc);
+ nv12_chroma_subpixel_clip_plane_top(data, IGT_ROTATION_90, plane, clip_fb, &ref_crc);
+ nv12_chroma_subpixel_clip_plane_top(data, IGT_ROTATION_180, plane, clip_fb, &ref_crc);
+ nv12_chroma_subpixel_clip_plane_top(data, IGT_ROTATION_270, plane, clip_fb, &ref_crc);
+
+ /* Reset to defaults */
+ igt_plane_set_position(plane, 0, 0);
+ igt_plane_set_rotation(plane, IGT_ROTATION_0);
+ igt_plane_set_fb(plane, plane == primary ? bg_fb : NULL);
+ }
+}
+
+static void run_tests_for_pipe(data_t *data, enum pipe pipe)
+{
+ igt_output_t *output;
+ igt_display_t *display = &data->display;
+
+ igt_fixture {
+ igt_display_require_output_on_pipe(display, pipe);
+ igt_require(pipe_supports_format(display, pipe, DRM_FORMAT_NV12));
+ }
+
+ igt_subtest_f("pipe-%s-nv12-rgb-switch", kmstest_pipe_name(pipe))
+ for_each_valid_output_on_pipe(display, pipe, output)
+ nv12_rgb_switch(data, pipe, output, false, DRM_FORMAT_NV12);
+
+ igt_subtest_f("pipe-%s-nv12-rgb-scaled-switch", kmstest_pipe_name(pipe))
+ for_each_valid_output_on_pipe(display, pipe, output)
+ nv12_rgb_switch(data, pipe, output, true, DRM_FORMAT_NV12);
+
+ igt_subtest_f("pipe-%s-nv12-valid-width", kmstest_pipe_name(pipe))
+ for_each_valid_output_on_pipe(display, pipe, output)
+ nv12_valid_width(data, pipe, output, DRM_FORMAT_NV12);
+
+ igt_subtest_f("pipe-%s-nv12-crop-scale-bug", kmstest_pipe_name(pipe))
+ for_each_valid_output_on_pipe(display, pipe, output)
+ nv12_crop_scale_bug(data, pipe, output, DRM_FORMAT_NV12);
+
+ igt_subtest_f("pipe-%s-nv12-chroma-subpixel-clip", kmstest_pipe_name(pipe))
+ for_each_valid_output_on_pipe(display, pipe, output)
+ nv12_chroma_subpixel_clip(data, pipe, output, DRM_FORMAT_NV12);
+}
+
+igt_main
+{
+ data_t data = {};
+ enum pipe pipe;
+
+ igt_skip_on_simulation();
+
+ igt_fixture {
+ data.display.drm_fd = drm_open_driver_master(DRIVER_ANY);
+
+ kmstest_set_vt_graphics_mode();
+ igt_display_init(&data.display, data.display.drm_fd);
+ igt_require(data.display.is_atomic);
+ igt_require_pipe_crc(data.display.drm_fd);
+ }
+
+ for_each_pipe_static(pipe)
+ igt_subtest_group
+ run_tests_for_pipe(&data, pipe);
+
+ igt_fixture {
+ igt_display_fini(&data.display);
+ close(data.display.drm_fd);
+ }
+}
diff --git a/tests/meson.build b/tests/meson.build
index 32c2156c6f4d..e5fab06bc2f2 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -166,6 +166,7 @@ test_progs = [
'kms_invalid_dotclock',
'kms_legacy_colorkey',
'kms_mmap_write_crc',
+ 'kms_nv12',
'kms_panel_fitting',
'kms_pipe_b_c_ivb',
'kms_pipe_crc_basic',
--
2.18.0
More information about the igt-dev
mailing list