* [igt-dev] [PATCH i-g-t 0/2] validate color tests using chamelium.
@ 2020-01-14 13:35 Kunal Joshi
2020-01-14 13:35 ` [igt-dev] [PATCH i-g-t 1/2] lib/igt_chamelium: add function to compare two frame dumps Kunal Joshi
` (3 more replies)
0 siblings, 4 replies; 6+ messages in thread
From: Kunal Joshi @ 2020-01-14 13:35 UTC (permalink / raw)
To: igt-dev; +Cc: Kunal Joshi, ville.syrjala, petri.latvala, daniel.vetter
For gen11+ platforms, there are frequent crc mismatch issues observed
in color tests. This is happening due to hardware limitation
(pipe rounding). One of the solutions to fix this is by rewriting
color tests and making them compatible with chamelium.
In this patch series, color tests are modified to have frame dump
comparison instead of crc comparison using chamelium hooks. This
will be useful even for future platforms. Also, with this approach
we could enable limited-range subtest which was commented in kms_color
because of crc mismatch.
Kunal Joshi (2):
lib/igt_chamelium: add function to compare two frame dumps.
tests/kms_color_chamelium: add subtests to validate color.
lib/igt_chamelium.c | 22 +
lib/igt_chamelium.h | 3 +
tests/Makefile.am | 1 +
tests/kms_color_chamelium.c | 1119 +++++++++++++++++++++++++++++++++++++++++++
tests/meson.build | 1 +
5 files changed, 1146 insertions(+)
create mode 100644 tests/kms_color_chamelium.c
--
2.7.4
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev
^ permalink raw reply [flat|nested] 6+ messages in thread
* [igt-dev] [PATCH i-g-t 1/2] lib/igt_chamelium: add function to compare two frame dumps.
2020-01-14 13:35 [igt-dev] [PATCH i-g-t 0/2] validate color tests using chamelium Kunal Joshi
@ 2020-01-14 13:35 ` Kunal Joshi
2020-01-14 13:35 ` [igt-dev] [PATCH i-g-t 2/2] tests/kms_color_chamelium: add subtests to validate color Kunal Joshi
` (2 subsequent siblings)
3 siblings, 0 replies; 6+ messages in thread
From: Kunal Joshi @ 2020-01-14 13:35 UTC (permalink / raw)
To: igt-dev; +Cc: Kunal Joshi, ville.syrjala, petri.latvala, daniel.vetter
Added chamelium_assert_frame_dump_eq() into lib. Function
is used to compare two frame dumps.
Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
Signed-off-by: Swati Sharma <swati2.sharma@intel.com>
Suggested-by: Uma Shankar <uma.shankar@intel.com>
---
lib/igt_chamelium.c | 22 ++++++++++++++++++++++
lib/igt_chamelium.h | 3 +++
2 files changed, 25 insertions(+)
diff --git a/lib/igt_chamelium.c b/lib/igt_chamelium.c
index 9971f51..0baf5bc 100644
--- a/lib/igt_chamelium.c
+++ b/lib/igt_chamelium.c
@@ -1519,6 +1519,28 @@ void chamelium_assert_frame_eq(const struct chamelium *chamelium,
}
/**
+ * chamelium_assert_frame_eq:
+ * @chamelium: The chamelium instance the frame dump belongs to
+ * @dump1: The chamelium frame dump to check
+ * @dump2: The chamelium frame dump to check
+ *
+ * Asserts that the image contained in the chamelium frame dump is
+ * identical to the other chamelium frame dump.
+ */
+bool chamelium_assert_frame_dump_eq(const struct chamelium *chamelium,
+ const struct chamelium_frame_dump *dump1,
+ const struct chamelium_frame_dump *dump2)
+{
+ bool eq;
+
+ /* Frame dump comparison */
+ eq = memcmp(dump1->bgr, dump2->bgr,
+ dump1->size) == 0;
+
+ return eq;
+}
+
+/**
* chamelium_assert_crc_eq_or_dump:
* @chamelium: The chamelium instance the frame dump belongs to
* @reference_crc: The CRC for the reference frame
diff --git a/lib/igt_chamelium.h b/lib/igt_chamelium.h
index 08705a9..6ff2d76 100644
--- a/lib/igt_chamelium.h
+++ b/lib/igt_chamelium.h
@@ -195,6 +195,9 @@ int chamelium_get_frame_limit(struct chamelium *chamelium,
void chamelium_assert_frame_eq(const struct chamelium *chamelium,
const struct chamelium_frame_dump *dump,
struct igt_fb *fb);
+bool chamelium_assert_frame_dump_eq(const struct chamelium *chamelium,
+ const struct chamelium_frame_dump *dump1,
+ const struct chamelium_frame_dump *dump2);
void chamelium_assert_crc_eq_or_dump(struct chamelium *chamelium,
igt_crc_t *reference_crc,
igt_crc_t *capture_crc, struct igt_fb *fb,
--
2.7.4
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev
^ permalink raw reply related [flat|nested] 6+ messages in thread
* [igt-dev] [PATCH i-g-t 2/2] tests/kms_color_chamelium: add subtests to validate color.
2020-01-14 13:35 [igt-dev] [PATCH i-g-t 0/2] validate color tests using chamelium Kunal Joshi
2020-01-14 13:35 ` [igt-dev] [PATCH i-g-t 1/2] lib/igt_chamelium: add function to compare two frame dumps Kunal Joshi
@ 2020-01-14 13:35 ` Kunal Joshi
2020-01-15 9:59 ` Arkadiusz Hiler
2020-01-14 14:22 ` [igt-dev] ✓ Fi.CI.BAT: success for validate color tests using chamelium Patchwork
2020-01-16 16:26 ` [igt-dev] ✓ Fi.CI.IGT: " Patchwork
3 siblings, 1 reply; 6+ messages in thread
From: Kunal Joshi @ 2020-01-14 13:35 UTC (permalink / raw)
To: igt-dev; +Cc: Kunal Joshi, ville.syrjala, petri.latvala, daniel.vetter
To validate color subtests using chamelium, subtests modified
to do frame dump comparison instead of crc comparison.
Tests require chamelium and will validate color features
at pipe level.
Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
Signed-off-by: Swati Sharma <swati2.sharma@intel.com>
Suggested-by: Uma Shankar <uma.shankar@intel.com>
---
tests/Makefile.am | 1 +
tests/kms_color_chamelium.c | 1119 +++++++++++++++++++++++++++++++++++++++++++
tests/meson.build | 1 +
3 files changed, 1121 insertions(+)
create mode 100644 tests/kms_color_chamelium.c
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 9a320bc..1794569 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -13,6 +13,7 @@ endif
if HAVE_CHAMELIUM
TESTS_progs += \
kms_chamelium \
+ kms_color_chamelium \
$(NULL)
endif
diff --git a/tests/kms_color_chamelium.c b/tests/kms_color_chamelium.c
new file mode 100644
index 0000000..0c87bf5
--- /dev/null
+++ b/tests/kms_color_chamelium.c
@@ -0,0 +1,1119 @@
+/*
+ * Copyright © 2020 Intel Corporation
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ *
+ */
+
+#include <math.h>
+#include <unistd.h>
+
+#include "drm.h"
+#include "drmtest.h"
+#include "igt.h"
+
+IGT_TEST_DESCRIPTION("Test Color Features at Pipe level");
+
+/* Internal */
+typedef struct {
+ double r, g, b;
+} color_t;
+
+typedef struct {
+ int drm_fd;
+ uint32_t devid;
+ igt_display_t display;
+
+ uint32_t color_depth;
+ uint64_t degamma_lut_size;
+ uint64_t gamma_lut_size;
+
+ struct chamelium *chamelium;
+ struct chamelium_port **ports;
+ int port_count;
+} data_t;
+
+typedef struct {
+ int size;
+ double coeffs[];
+} gamma_lut_t;
+
+static void paint_gradient_rectangles(data_t *data,
+ drmModeModeInfo *mode,
+ color_t *colors,
+ struct igt_fb *fb)
+{
+ cairo_t *cr = igt_get_cairo_ctx(data->drm_fd, fb);
+ int i, l = mode->hdisplay / 3;
+ int rows_remaining = mode->hdisplay % 3;
+
+ /* Paint 3 gradient rectangles with red/green/blue between 1.0 and
+ * 0.5. We want to avoid 0 so each max LUTs only affect their own
+ * rectangle.
+ */
+ for (i = 0 ; i < 3; i++) {
+ igt_paint_color_gradient_range(cr, i * l, 0, l, mode->vdisplay,
+ colors[i].r != 0 ? 0.2 : 0,
+ colors[i].g != 0 ? 0.2 : 0,
+ colors[i].b != 0 ? 0.2 : 0,
+ colors[i].r,
+ colors[i].g,
+ colors[i].b);
+ }
+
+ if (rows_remaining > 0)
+ igt_paint_color_gradient_range(cr, i * l, 0, rows_remaining,
+ mode->vdisplay,
+ colors[i-1].r != 0 ? 0.2 : 0,
+ colors[i-1].g != 0 ? 0.2 : 0,
+ colors[i-1].b != 0 ? 0.2 : 0,
+ colors[i-1].r,
+ colors[i-1].g,
+ colors[i-1].b);
+
+ igt_put_cairo_ctx(data->drm_fd, fb, cr);
+}
+
+static void paint_rectangles(data_t *data,
+ drmModeModeInfo *mode,
+ color_t *colors,
+ struct igt_fb *fb)
+{
+ cairo_t *cr = igt_get_cairo_ctx(data->drm_fd, fb);
+ int i, l = mode->hdisplay / 3;
+ int rows_remaining = mode->hdisplay % 3;
+
+ /* Paint 3 solid rectangles. */
+ for (i = 0 ; i < 3; i++) {
+ igt_paint_color(cr, i * l, 0, l, mode->vdisplay,
+ colors[i].r, colors[i].g, colors[i].b);
+ }
+
+ if (rows_remaining > 0)
+ igt_paint_color(cr, i * l, 0, rows_remaining, mode->vdisplay,
+ colors[i-1].r, colors[i-1].g, colors[i-1].b);
+
+ igt_put_cairo_ctx(data->drm_fd, fb, cr);
+}
+
+static gamma_lut_t *alloc_lut(int lut_size)
+{
+ gamma_lut_t *gamma;
+
+ igt_assert_lt(0, lut_size);
+
+ gamma = malloc(sizeof(*gamma) + lut_size * sizeof(gamma->coeffs[0]));
+ igt_assert(gamma);
+ gamma->size = lut_size;
+
+ return gamma;
+}
+
+static void free_lut(gamma_lut_t *gamma)
+{
+ if (!gamma)
+ return;
+
+ free(gamma);
+}
+
+static gamma_lut_t *generate_table(int lut_size, double exp)
+{
+ gamma_lut_t *gamma = alloc_lut(lut_size);
+ int i;
+
+ gamma->coeffs[0] = 0.0;
+ for (i = 1; i < lut_size; i++)
+ gamma->coeffs[i] = pow(i * 1.0 / (lut_size - 1), exp);
+
+ return gamma;
+}
+
+static gamma_lut_t *generate_table_max(int lut_size)
+{
+ gamma_lut_t *gamma = alloc_lut(lut_size);
+ int i;
+
+ gamma->coeffs[0] = 0.0;
+ for (i = 1; i < lut_size; i++)
+ gamma->coeffs[i] = 1.0;
+
+ return gamma;
+}
+
+static struct drm_color_lut *coeffs_to_lut(data_t *data,
+ const gamma_lut_t *gamma,
+ uint32_t color_depth,
+ int off)
+{
+ struct drm_color_lut *lut;
+ int i, lut_size = gamma->size;
+ uint32_t max_value = (1 << 16) - 1;
+ uint32_t mask;
+
+ if (is_i915_device(data->drm_fd))
+ mask = ((1 << color_depth) - 1) << 8;
+ else
+ mask = max_value;
+
+ lut = malloc(sizeof(struct drm_color_lut) * lut_size);
+
+ if (IS_CHERRYVIEW(data->devid))
+ lut_size -= 1;
+ for (i = 0; i < lut_size; i++) {
+ uint32_t v = (gamma->coeffs[i] * max_value);
+
+ v &= mask;
+
+ lut[i].red = v;
+ lut[i].green = v;
+ lut[i].blue = v;
+ }
+
+ if (IS_CHERRYVIEW(data->devid))
+ lut[lut_size].red =
+ lut[lut_size].green =
+ lut[lut_size].blue = lut[lut_size - 1].red;
+
+ return lut;
+}
+
+static void set_degamma(data_t *data,
+ igt_pipe_t *pipe,
+ const gamma_lut_t *gamma)
+{
+ size_t size = sizeof(struct drm_color_lut) * gamma->size;
+ struct drm_color_lut *lut = coeffs_to_lut(data, gamma,
+ data->color_depth, 0);
+
+ free(lut);
+}
+
+static void set_gamma(data_t *data,
+ igt_pipe_t *pipe,
+ const gamma_lut_t *gamma)
+{
+ size_t size = sizeof(struct drm_color_lut) * gamma->size;
+ struct drm_color_lut *lut = coeffs_to_lut(data, gamma,
+ data->color_depth, 0);
+
+ igt_pipe_obj_replace_prop_blob(pipe, IGT_CRTC_GAMMA_LUT, lut, size);
+
+ free(lut);
+}
+
+static void set_ctm(igt_pipe_t *pipe, const double *coefficients)
+{
+ struct drm_color_ctm ctm;
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(ctm.matrix); i++) {
+ if (coefficients[i] < 0) {
+ ctm.matrix[i] =
+ (int64_t) (-coefficients[i] *
+ ((int64_t) 1L << 32));
+ ctm.matrix[i] |= 1ULL << 63;
+ } else
+ ctm.matrix[i] =
+ (int64_t) (coefficients[i] *
+ ((int64_t) 1L << 32));
+ }
+
+ igt_pipe_obj_replace_prop_blob(pipe, IGT_CRTC_CTM, &ctm, sizeof(ctm));
+}
+
+static void disable_prop(igt_pipe_t *pipe, enum igt_atomic_crtc_properties prop)
+{
+ if (igt_pipe_obj_has_prop(pipe, prop))
+ igt_pipe_obj_replace_prop_blob(pipe, prop, NULL, 0);
+}
+
+#define disable_degamma(pipe) disable_prop(pipe, IGT_CRTC_DEGAMMA_LUT)
+#define disable_gamma(pipe) disable_prop(pipe, IGT_CRTC_GAMMA_LUT)
+#define disable_ctm(pipe) disable_prop(pipe, IGT_CRTC_CTM)
+
+/*
+ * Draw 3 gradient rectangles in red, green and blue, with a maxed out
+ * degamma LUT and verify we have the same frame dump as drawing solid color
+ * rectangles with linear degamma LUT.
+ */
+static void test_pipe_degamma(data_t *data,
+ igt_plane_t *primary)
+{
+ igt_output_t *output;
+ gamma_lut_t *degamma_linear, *degamma_full;
+ gamma_lut_t *gamma_linear;
+ color_t red_green_blue[] = {
+ { 1.0, 0.0, 0.0 },
+ { 0.0, 1.0, 0.0 },
+ { 0.0, 0.0, 1.0 }
+ };
+
+ int i;
+ struct chamelium_port *port;
+ char *connected_ports[4];
+ bool valid_output = false;
+
+ for (i = 0; i < data->port_count; i++)
+ connected_ports[i] =
+ (char *) chamelium_port_get_name(data->ports[i]);
+
+ igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_DEGAMMA_LUT));
+ igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_GAMMA_LUT));
+
+ degamma_linear = generate_table(data->degamma_lut_size, 1.0);
+ degamma_full = generate_table_max(data->degamma_lut_size);
+
+ gamma_linear = generate_table(data->gamma_lut_size, 1.0);
+
+ for_each_valid_output_on_pipe(&data->display,
+ primary->pipe->pipe,
+ output) {
+ drmModeModeInfo *mode;
+ struct igt_fb fb_modeset, fb;
+ struct chamelium_frame_dump *frame_fullgamma, *frame_fullcolors;
+ int fb_id, fb_modeset_id;
+
+ for (i = 0; i < data->port_count; i++)
+ valid_output |=
+ (strcmp(output->name, connected_ports[i]) == 0);
+ if (!valid_output)
+ continue;
+ else
+ for (i = 0; i < data->port_count; i++)
+ if (strcmp(output->name,
+ connected_ports[i]) == 0)
+ port = data->ports[i];
+
+ igt_output_set_pipe(output, primary->pipe->pipe);
+ mode = igt_output_get_mode(output);
+
+ /* Create a framebuffer at the size of the output. */
+ fb_id = igt_create_fb(data->drm_fd,
+ mode->hdisplay,
+ mode->vdisplay,
+ DRM_FORMAT_XRGB8888,
+ LOCAL_DRM_FORMAT_MOD_NONE,
+ &fb);
+ igt_assert(fb_id);
+
+ fb_modeset_id = igt_create_fb(data->drm_fd,
+ mode->hdisplay,
+ mode->vdisplay,
+ DRM_FORMAT_XRGB8888,
+ LOCAL_DRM_FORMAT_MOD_NONE,
+ &fb_modeset);
+ igt_assert(fb_modeset_id);
+
+ igt_plane_set_fb(primary, &fb_modeset);
+ disable_ctm(primary->pipe);
+ disable_degamma(primary->pipe);
+ set_gamma(data, primary->pipe, gamma_linear);
+ igt_display_commit(&data->display);
+
+ /* Draw solid colors with no degamma transformation. */
+ paint_rectangles(data, mode, red_green_blue, &fb);
+ igt_plane_set_fb(primary, &fb);
+ igt_display_commit(&data->display);
+ chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
+ frame_fullgamma =
+ chamelium_read_captured_frame(data->chamelium, 0);
+
+ /* Draw a gradient with degamma LUT to remap all
+ * values to max red/green/blue.
+ */
+ paint_gradient_rectangles(data, mode, red_green_blue, &fb);
+ igt_plane_set_fb(primary, &fb);
+ set_degamma(data, primary->pipe, degamma_full);
+ igt_display_commit(&data->display);
+ chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
+ frame_fullcolors =
+ chamelium_read_captured_frame(data->chamelium, 0);
+
+ /* Verify that the frame dump of the software computed output
+ * is equal to the frame dump of the degamma LUT transformation
+ * output.
+ */
+ igt_assert(chamelium_assert_frame_dump_eq(data->chamelium,
+ frame_fullgamma,
+ frame_fullcolors));
+
+ igt_plane_set_fb(primary, NULL);
+ igt_output_set_pipe(output, PIPE_NONE);
+ }
+
+ free_lut(degamma_linear);
+ free_lut(degamma_full);
+ free_lut(gamma_linear);
+}
+
+/*
+ * Draw 3 gradient rectangles in red, green and blue, with a maxed out
+ * gamma LUT and verify we have the same frame dump as drawing solid
+ * color rectangles.
+ */
+static void test_pipe_gamma(data_t *data,
+ igt_plane_t *primary)
+{
+ igt_output_t *output;
+ gamma_lut_t *gamma_full;
+ color_t red_green_blue[] = {
+ { 1.0, 0.0, 0.0 },
+ { 0.0, 1.0, 0.0 },
+ { 0.0, 0.0, 1.0 }
+ };
+
+ int i;
+ struct chamelium_port *port;
+ char *connected_ports[4];
+ bool valid_output = false;
+
+ for (i = 0; i < data->port_count; i++)
+ connected_ports[i] =
+ (char *) chamelium_port_get_name(data->ports[i]);
+
+ igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_GAMMA_LUT));
+
+ gamma_full = generate_table_max(data->gamma_lut_size);
+
+ for_each_valid_output_on_pipe(&data->display,
+ primary->pipe->pipe,
+ output) {
+ drmModeModeInfo *mode;
+ struct igt_fb fb_modeset, fb;
+ struct chamelium_frame_dump *frame_fullgamma, *frame_fullcolors;
+ int fb_id, fb_modeset_id;
+
+ for (i = 0; i < data->port_count; i++)
+ valid_output |=
+ (strcmp(output->name, connected_ports[i]) == 0);
+ if (!valid_output)
+ continue;
+ else
+ for (i = 0; i < data->port_count; i++)
+ if (strcmp(output->name,
+ connected_ports[i]) == 0)
+ port = data->ports[i];
+
+ igt_output_set_pipe(output, primary->pipe->pipe);
+ mode = igt_output_get_mode(output);
+
+ /* Create a framebuffer at the size of the output. */
+ fb_id = igt_create_fb(data->drm_fd,
+ mode->hdisplay,
+ mode->vdisplay,
+ DRM_FORMAT_XRGB8888,
+ LOCAL_DRM_FORMAT_MOD_NONE,
+ &fb);
+ igt_assert(fb_id);
+
+ fb_modeset_id = igt_create_fb(data->drm_fd,
+ mode->hdisplay,
+ mode->vdisplay,
+ DRM_FORMAT_XRGB8888,
+ LOCAL_DRM_FORMAT_MOD_NONE,
+ &fb_modeset);
+ igt_assert(fb_modeset_id);
+
+ igt_plane_set_fb(primary, &fb_modeset);
+ disable_ctm(primary->pipe);
+ disable_degamma(primary->pipe);
+ set_gamma(data, primary->pipe, gamma_full);
+ igt_display_commit(&data->display);
+
+ /* Draw solid colors with no gamma transformation. */
+ paint_rectangles(data, mode, red_green_blue, &fb);
+ igt_plane_set_fb(primary, &fb);
+ igt_display_commit(&data->display);
+ chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
+ frame_fullgamma =
+ chamelium_read_captured_frame(data->chamelium, 0);
+
+ /* Draw a gradient with gamma LUT to remap all values
+ * to max red/green/blue.
+ */
+ paint_gradient_rectangles(data, mode, red_green_blue, &fb);
+ igt_plane_set_fb(primary, &fb);
+ igt_display_commit(&data->display);
+ chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
+ frame_fullcolors =
+ chamelium_read_captured_frame(data->chamelium, 0);
+
+ /* Verify that the frame dump of the software computed output is
+ * equal to the frame dump of the degamma LUT transformation
+ * output.
+ */
+ igt_assert(chamelium_assert_frame_dump_eq(data->chamelium,
+ frame_fullgamma,
+ frame_fullcolors));
+
+ igt_plane_set_fb(primary, NULL);
+ igt_output_set_pipe(output, PIPE_NONE);
+ }
+
+ free_lut(gamma_full);
+}
+
+/*
+ * Draw 3 rectangles using before colors with the ctm matrix apply and verify
+ * the frame dump is equal to using after colors with an identify ctm matrix.
+ */
+static bool test_pipe_ctm(data_t *data,
+ igt_plane_t *primary,
+ 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
+ };
+ gamma_lut_t *degamma_linear, *gamma_linear;
+ igt_output_t *output;
+
+ int i;
+ bool ret = true;
+ struct chamelium_port *port;
+ char *connected_ports[4];
+ bool valid_output = false;
+
+ igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_CTM));
+
+ for (i = 0; i < data->port_count; i++)
+ connected_ports[i] =
+ (char *) chamelium_port_get_name(data->ports[i]);
+
+ degamma_linear = generate_table(data->degamma_lut_size, 1.0);
+ gamma_linear = generate_table(data->gamma_lut_size, 1.0);
+
+ for_each_valid_output_on_pipe(&data->display,
+ primary->pipe->pipe,
+ output) {
+ drmModeModeInfo *mode;
+ struct igt_fb fb_modeset, fb;
+ struct chamelium_frame_dump *frame_software, *frame_hardware;
+ int fb_id, fb_modeset_id;
+
+ for (i = 0; i < data->port_count; i++)
+ valid_output |=
+ (strcmp(output->name, connected_ports[i]) == 0);
+ if (!valid_output)
+ continue;
+ else
+ for (i = 0; i < data->port_count; i++)
+ if (strcmp(output->name,
+ connected_ports[i]) == 0)
+ port = data->ports[i];
+
+ igt_output_set_pipe(output, primary->pipe->pipe);
+ mode = igt_output_get_mode(output);
+
+ /* Create a framebuffer at the size of the output. */
+ fb_id = igt_create_fb(data->drm_fd,
+ mode->hdisplay,
+ mode->vdisplay,
+ DRM_FORMAT_XRGB8888,
+ LOCAL_DRM_FORMAT_MOD_NONE,
+ &fb);
+ igt_assert(fb_id);
+
+ fb_modeset_id = igt_create_fb(data->drm_fd,
+ mode->hdisplay,
+ mode->vdisplay,
+ DRM_FORMAT_XRGB8888,
+ LOCAL_DRM_FORMAT_MOD_NONE,
+ &fb_modeset);
+ igt_assert(fb_modeset_id);
+ igt_plane_set_fb(primary, &fb_modeset);
+
+ if (memcmp(before, after, sizeof(color_t))) {
+ set_degamma(data, primary->pipe, degamma_linear);
+ set_gamma(data, primary->pipe, gamma_linear);
+ } else {
+ /* Disable Degamma and Gamma for ctm max test */
+ disable_degamma(primary->pipe);
+ disable_gamma(primary->pipe);
+ }
+
+ disable_ctm(primary->pipe);
+ igt_display_commit(&data->display);
+
+ paint_rectangles(data, mode, after, &fb);
+ igt_plane_set_fb(primary, &fb);
+ set_ctm(primary->pipe, ctm_identity);
+ igt_display_commit(&data->display);
+ chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
+ frame_software =
+ chamelium_read_captured_frame(data->chamelium, 0);
+
+ /* With CTM transformation. */
+ paint_rectangles(data, mode, before, &fb);
+ igt_plane_set_fb(primary, &fb);
+ set_ctm(primary->pipe, ctm_matrix);
+ igt_display_commit(&data->display);
+ chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
+ frame_hardware =
+ chamelium_read_captured_frame(data->chamelium, 0);
+
+ /* Verify that the frame dump of the software computed output is
+ * equal to the frame dump of the CTM matrix transformation
+ * output.
+ */
+ ret &= chamelium_assert_frame_dump_eq(data->chamelium,
+ frame_software,
+ frame_hardware);
+
+ igt_plane_set_fb(primary, NULL);
+ igt_output_set_pipe(output, PIPE_NONE);
+ }
+
+ free_lut(degamma_linear);
+ free_lut(gamma_linear);
+
+ return ret;
+}
+
+static void test_pipe_limited_range_ctm(data_t *data,
+ igt_plane_t *primary)
+{
+ double limited_result = 235.0 / 255.0;
+ color_t red_green_blue_limited[] = {
+ { limited_result, 0.0, 0.0 },
+ { 0.0, limited_result, 0.0 },
+ { 0.0, 0.0, limited_result }
+ };
+ color_t red_green_blue_full[] = {
+ { 0.5, 0.0, 0.0 },
+ { 0.0, 0.5, 0.0 },
+ { 0.0, 0.0, 0.5 }
+ };
+ double ctm[] = { 1.0, 0.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 0.0, 1.0 };
+ gamma_lut_t *degamma_linear, *gamma_linear;
+ igt_output_t *output;
+ bool has_broadcast_rgb_output = false;
+
+ int i;
+ struct chamelium_port *port;
+ char *connected_ports[4];
+ bool valid_output = false;
+
+ degamma_linear = generate_table(data->degamma_lut_size, 1.0);
+ gamma_linear = generate_table(data->gamma_lut_size, 1.0);
+
+ for (i = 0; i < data->port_count; i++)
+ connected_ports[i] =
+ (char *) chamelium_port_get_name(data->ports[i]);
+
+ for_each_valid_output_on_pipe(&data->display,
+ primary->pipe->pipe,
+ output) {
+ drmModeModeInfo *mode;
+ struct igt_fb fb_modeset, fb;
+ struct chamelium_frame_dump *frame_full, *frame_limited;
+ int fb_id, fb_modeset_id;
+
+ for (i = 0; i < data->port_count; i++)
+ valid_output |=
+ (strcmp(output->name, connected_ports[i]) == 0);
+ if (!valid_output)
+ continue;
+ else
+ for (i = 0; i < data->port_count; i++)
+ if (strcmp(output->name,
+ connected_ports[i]) == 0)
+ port = data->ports[i];
+
+ if (!igt_output_has_prop(output, IGT_CONNECTOR_BROADCAST_RGB))
+ continue;
+
+ has_broadcast_rgb_output = true;
+
+ igt_output_set_pipe(output, primary->pipe->pipe);
+ mode = igt_output_get_mode(output);
+
+ /* Create a framebuffer at the size of the output. */
+ fb_id = igt_create_fb(data->drm_fd,
+ mode->hdisplay,
+ mode->vdisplay,
+ DRM_FORMAT_XRGB8888,
+ LOCAL_DRM_FORMAT_MOD_NONE,
+ &fb);
+ igt_assert(fb_id);
+
+ fb_modeset_id = igt_create_fb(data->drm_fd,
+ mode->hdisplay,
+ mode->vdisplay,
+ DRM_FORMAT_XRGB8888,
+ LOCAL_DRM_FORMAT_MOD_NONE,
+ &fb_modeset);
+ igt_assert(fb_modeset_id);
+ igt_plane_set_fb(primary, &fb_modeset);
+
+ set_degamma(data, primary->pipe, degamma_linear);
+ set_gamma(data, primary->pipe, gamma_linear);
+ set_ctm(primary->pipe, ctm);
+
+ igt_output_set_prop_value(output,
+ IGT_CONNECTOR_BROADCAST_RGB,
+ BROADCAST_RGB_FULL);
+ paint_rectangles(data, mode, red_green_blue_limited, &fb);
+ igt_plane_set_fb(primary, &fb);
+ igt_display_commit(&data->display);
+
+ /* Set the output into limited range. */
+ igt_output_set_prop_value(output,
+ IGT_CONNECTOR_BROADCAST_RGB,
+ BROADCAST_RGB_16_235);
+ paint_rectangles(data, mode, red_green_blue_full, &fb);
+ igt_plane_set_fb(primary, &fb);
+ igt_display_commit(&data->display);
+ chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
+ frame_full =
+ chamelium_read_captured_frame(data->chamelium, 0);
+
+
+ /* And reset.. */
+ igt_output_set_prop_value(output,
+ IGT_CONNECTOR_BROADCAST_RGB,
+ BROADCAST_RGB_FULL);
+ igt_plane_set_fb(primary, NULL);
+ igt_output_set_pipe(output, PIPE_NONE);
+ chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
+ frame_limited =
+ chamelium_read_captured_frame(data->chamelium, 0);
+
+
+ /* Verify that the frame dump of the software computed output is
+ * equal to the frame dump of the CTM matrix transformation
+ * output.
+ */
+ igt_assert(chamelium_assert_frame_dump_eq(data->chamelium,
+ frame_full,
+ frame_limited));
+ }
+
+ free_lut(gamma_linear);
+ free_lut(degamma_linear);
+
+ igt_require(has_broadcast_rgb_output);
+}
+
+static void
+run_tests_for_pipe(data_t *data, enum pipe p)
+{
+ igt_pipe_t *pipe;
+ igt_plane_t *primary;
+ double delta;
+ int i;
+ color_t red_green_blue[] = {
+ { 1.0, 0.0, 0.0 },
+ { 0.0, 1.0, 0.0 },
+ { 0.0, 0.0, 1.0 }
+ };
+
+ igt_fixture {
+
+ igt_require(p < data->display.n_pipes);
+
+ pipe = &data->display.pipes[p];
+ igt_require(pipe->n_planes >= 0);
+
+ primary = igt_pipe_get_plane_type(pipe, DRM_PLANE_TYPE_PRIMARY);
+
+ if (igt_pipe_obj_has_prop(&data->display.pipes[p],
+ IGT_CRTC_DEGAMMA_LUT_SIZE)) {
+ data->degamma_lut_size =
+ igt_pipe_obj_get_prop(&data->display.pipes[p],
+ IGT_CRTC_DEGAMMA_LUT_SIZE);
+ igt_assert_lt(0, data->degamma_lut_size);
+ }
+
+ if (igt_pipe_obj_has_prop(&data->display.pipes[p],
+ IGT_CRTC_GAMMA_LUT_SIZE)) {
+ data->gamma_lut_size =
+ igt_pipe_obj_get_prop(&data->display.pipes[p],
+ IGT_CRTC_GAMMA_LUT_SIZE);
+ igt_assert_lt(0, data->gamma_lut_size);
+ }
+
+ igt_display_require_output_on_pipe(&data->display, p);
+ }
+
+ data->color_depth = 8;
+ delta = 1.0 / (1 << data->color_depth);
+
+ igt_describe("Compare after applying ctm matrix & identity matrix");
+ igt_subtest_f("pipe-%s-ctm-red-to-blue", kmstest_pipe_name(p)) {
+ color_t blue_green_blue[] = {
+ { 0.0, 0.0, 1.0 },
+ { 0.0, 1.0, 0.0 },
+ { 0.0, 0.0, 1.0 }
+ };
+ double ctm[] = { 0.0, 0.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 1.0, 0.0, 1.0 };
+ igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+ blue_green_blue, ctm));
+ }
+
+ igt_describe("Compare after applying ctm matrix & identity matrix");
+ igt_subtest_f("pipe-%s-ctm-green-to-red", kmstest_pipe_name(p)) {
+ color_t red_red_blue[] = {
+ { 1.0, 0.0, 0.0 },
+ { 1.0, 0.0, 0.0 },
+ { 0.0, 0.0, 1.0 }
+ };
+ double ctm[] = { 1.0, 1.0, 0.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 0.0, 1.0 };
+ igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+ red_red_blue, ctm));
+ }
+
+ igt_describe("Compare after applying ctm matrix & identity matrix");
+ igt_subtest_f("pipe-%s-ctm-blue-to-red", kmstest_pipe_name(p)) {
+ color_t red_green_red[] = {
+ { 1.0, 0.0, 0.0 },
+ { 0.0, 1.0, 0.0 },
+ { 1.0, 0.0, 0.0 }
+ };
+ double ctm[] = { 1.0, 0.0, 1.0,
+ 0.0, 1.0, 0.0,
+ 0.0, 0.0, 0.0 };
+ igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+ red_green_red, ctm));
+ }
+
+ /* We tests a few values around the expected result because
+ * the it depends on the hardware we're dealing with, we can
+ * either get clamped or rounded values and we also need to
+ * account for odd number of items in the LUTs.
+ */
+ igt_describe("Compare after applying ctm matrix & identity matrix");
+ igt_subtest_f("pipe-%s-ctm-0-25", kmstest_pipe_name(p)) {
+ color_t expected_colors[] = {
+ { 0.0, }, { 0.0, }, { 0.0, }
+ };
+ double ctm[] = { 0.25, 0.0, 0.0,
+ 0.0, 0.25, 0.0,
+ 0.0, 0.0, 0.25 };
+ bool success = false;
+
+ for (i = 0; i < 5; i++) {
+ expected_colors[0].r =
+ expected_colors[1].g =
+ expected_colors[2].b =
+ 0.25 + delta * (i - 2);
+ success |= test_pipe_ctm(data, primary,
+ red_green_blue,
+ expected_colors, ctm);
+ }
+ igt_assert(success);
+ }
+
+ igt_describe("Compare after applying ctm matrix & identity matrix");
+ igt_subtest_f("pipe-%s-ctm-0-5", kmstest_pipe_name(p)) {
+ color_t expected_colors[] = {
+ { 0.0, }, { 0.0, }, { 0.0, }
+ };
+ double ctm[] = { 0.5, 0.0, 0.0,
+ 0.0, 0.5, 0.0,
+ 0.0, 0.0, 0.5 };
+ bool success = false;
+
+ for (i = 0; i < 5; i++) {
+ expected_colors[0].r =
+ expected_colors[1].g =
+ expected_colors[2].b =
+ 0.5 + delta * (i - 2);
+ success |= test_pipe_ctm(data, primary,
+ red_green_blue,
+ expected_colors, ctm);
+ }
+ igt_assert(success);
+ }
+
+ igt_describe("Compare after applying ctm matrix & identity matrix");
+ igt_subtest_f("pipe-%s-ctm-0-75", kmstest_pipe_name(p)) {
+ color_t expected_colors[] = {
+ { 0.0, }, { 0.0, }, { 0.0, }
+ };
+ double ctm[] = { 0.75, 0.0, 0.0,
+ 0.0, 0.75, 0.0,
+ 0.0, 0.0, 0.75 };
+ bool success = false;
+
+ for (i = 0; i < 7; i++) {
+ expected_colors[0].r =
+ expected_colors[1].g =
+ expected_colors[2].b =
+ 0.75 + delta * (i - 3);
+ success |= test_pipe_ctm(data, primary,
+ red_green_blue,
+ expected_colors, ctm);
+ }
+ igt_assert(success);
+ }
+
+ igt_describe("Compare after applying ctm matrix & identity matrix");
+ igt_subtest_f("pipe-%s-ctm-max", kmstest_pipe_name(p)) {
+ color_t full_rgb[] = {
+ { 1.0, 0.0, 0.0 },
+ { 0.0, 1.0, 0.0 },
+ { 0.0, 0.0, 1.0 }
+ };
+ double ctm[] = { 100.0, 0.0, 0.0,
+ 0.0, 100.0, 0.0,
+ 0.0, 0.0, 100.0 };
+
+ /* CherryView generates values on 10bits that we
+ * produce with an 8 bits per color framebuffer.
+ */
+ igt_require(!IS_CHERRYVIEW(data->devid));
+
+ igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+ full_rgb, ctm));
+ }
+
+ igt_describe("Compare after applying ctm matrix & identity matrix");
+ igt_subtest_f("pipe-%s-ctm-negative", kmstest_pipe_name(p)) {
+ color_t all_black[] = {
+ { 0.0, 0.0, 0.0 },
+ { 0.0, 0.0, 0.0 },
+ { 0.0, 0.0, 0.0 }
+ };
+ double ctm[] = { -1.0, 0.0, 0.0,
+ 0.0, -1.0, 0.0,
+ 0.0, 0.0, -1.0 };
+ igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+ all_black, ctm));
+ }
+
+ igt_describe("Compare after applying ctm matrix & identity matrix");
+ igt_subtest_f("pipe-%s-ctm-limited-range", kmstest_pipe_name(p))
+ test_pipe_limited_range_ctm(data, primary);
+
+ igt_describe("Compare maxed out gamma LUT and solid color linear LUT");
+ igt_subtest_f("pipe-%s-degamma", kmstest_pipe_name(p))
+ test_pipe_degamma(data, primary);
+
+ igt_describe("Compare maxed out gamma LUT and solid color linear LUT");
+ igt_subtest_f("pipe-%s-gamma", kmstest_pipe_name(p))
+ test_pipe_gamma(data, primary);
+
+ igt_fixture {
+ disable_degamma(primary->pipe);
+ disable_gamma(primary->pipe);
+ disable_ctm(primary->pipe);
+ igt_display_commit(&data->display);
+ }
+}
+
+static int
+pipe_set_property_blob_id(igt_pipe_t *pipe,
+ enum igt_atomic_crtc_properties prop,
+ uint32_t blob_id)
+{
+ int ret;
+
+ igt_pipe_obj_replace_prop_blob(pipe, prop, NULL, 0);
+
+ igt_pipe_obj_set_prop_value(pipe, prop, blob_id);
+
+ ret = igt_display_try_commit2(pipe->display,
+ pipe->display->is_atomic ?
+ COMMIT_ATOMIC : COMMIT_LEGACY);
+
+ igt_pipe_obj_set_prop_value(pipe, prop, 0);
+
+ return ret;
+}
+
+static int
+pipe_set_property_blob(igt_pipe_t *pipe,
+ enum igt_atomic_crtc_properties prop,
+ void *ptr, size_t length)
+{
+ igt_pipe_obj_replace_prop_blob(pipe, prop, ptr, length);
+
+ return igt_display_try_commit2(pipe->display,
+ pipe->display->is_atomic ?
+ COMMIT_ATOMIC : COMMIT_LEGACY);
+}
+
+static void
+invalid_gamma_lut_sizes(data_t *data)
+{
+ igt_display_t *display = &data->display;
+ igt_pipe_t *pipe = &display->pipes[0];
+ size_t gamma_lut_size = data->gamma_lut_size *
+ sizeof(struct drm_color_lut);
+ struct drm_color_lut *gamma_lut;
+
+ igt_require(igt_pipe_obj_has_prop(pipe, IGT_CRTC_GAMMA_LUT));
+
+ gamma_lut = malloc(gamma_lut_size * 2);
+
+ igt_display_commit2(display,
+ display->is_atomic ?
+ COMMIT_ATOMIC : COMMIT_LEGACY);
+
+ igt_assert_eq(pipe_set_property_blob(pipe,
+ IGT_CRTC_GAMMA_LUT,
+ gamma_lut, 1),
+ -EINVAL);
+ igt_assert_eq(pipe_set_property_blob(pipe,
+ IGT_CRTC_GAMMA_LUT,
+ gamma_lut, gamma_lut_size + 1),
+ -EINVAL);
+ igt_assert_eq(pipe_set_property_blob(pipe,
+ IGT_CRTC_GAMMA_LUT,
+ gamma_lut,
+ gamma_lut_size - 1),
+ -EINVAL);
+ igt_assert_eq(pipe_set_property_blob(pipe,
+ IGT_CRTC_GAMMA_LUT,
+ gamma_lut,
+ gamma_lut_size +
+ sizeof(struct drm_color_lut)),
+ -EINVAL);
+ igt_assert_eq(pipe_set_property_blob_id(pipe,
+ IGT_CRTC_GAMMA_LUT,
+ pipe->crtc_id),
+ -EINVAL);
+ igt_assert_eq(pipe_set_property_blob_id(pipe,
+ IGT_CRTC_GAMMA_LUT,
+ 4096 * 4096),
+ -EINVAL);
+
+ free(gamma_lut);
+}
+
+static void
+invalid_degamma_lut_sizes(data_t *data)
+{
+ igt_display_t *display = &data->display;
+ igt_pipe_t *pipe = &display->pipes[0];
+ size_t degamma_lut_size = data->degamma_lut_size *
+ sizeof(struct drm_color_lut);
+ struct drm_color_lut *degamma_lut;
+
+ igt_require(igt_pipe_obj_has_prop(pipe, IGT_CRTC_DEGAMMA_LUT));
+
+ degamma_lut = malloc(degamma_lut_size * 2);
+
+ igt_display_commit2(display,
+ display->is_atomic ?
+ COMMIT_ATOMIC : COMMIT_LEGACY);
+
+ igt_assert_eq(pipe_set_property_blob(pipe, IGT_CRTC_DEGAMMA_LUT,
+ degamma_lut, 1), -EINVAL);
+ igt_assert_eq(pipe_set_property_blob(pipe, IGT_CRTC_DEGAMMA_LUT,
+ degamma_lut, degamma_lut_size + 1),
+ -EINVAL);
+ igt_assert_eq(pipe_set_property_blob(pipe, IGT_CRTC_DEGAMMA_LUT,
+ degamma_lut,
+ degamma_lut_size - 1),
+ -EINVAL);
+ igt_assert_eq(pipe_set_property_blob(pipe, IGT_CRTC_DEGAMMA_LUT,
+ degamma_lut,
+ degamma_lut_size +
+ sizeof(struct drm_color_lut)),
+ -EINVAL);
+ igt_assert_eq(pipe_set_property_blob_id(pipe, IGT_CRTC_DEGAMMA_LUT,
+ pipe->crtc_id), -EINVAL);
+ igt_assert_eq(pipe_set_property_blob_id(pipe, IGT_CRTC_DEGAMMA_LUT,
+ 4096 * 4096), -EINVAL);
+
+ free(degamma_lut);
+}
+
+static void
+invalid_ctm_matrix_sizes(data_t *data)
+{
+ igt_display_t *display = &data->display;
+ igt_pipe_t *pipe = &display->pipes[0];
+ void *ptr;
+
+ igt_require(igt_pipe_obj_has_prop(pipe, IGT_CRTC_CTM));
+
+ ptr = malloc(sizeof(struct drm_color_ctm) * 4);
+
+ igt_assert_eq(pipe_set_property_blob(pipe, IGT_CRTC_CTM, ptr, 1),
+ -EINVAL);
+ igt_assert_eq(pipe_set_property_blob(pipe, IGT_CRTC_CTM, ptr,
+ sizeof(struct drm_color_ctm) + 1),
+ -EINVAL);
+ igt_assert_eq(pipe_set_property_blob(pipe, IGT_CRTC_CTM, ptr,
+ sizeof(struct drm_color_ctm) - 1),
+ -EINVAL);
+ igt_assert_eq(pipe_set_property_blob(pipe, IGT_CRTC_CTM, ptr,
+ sizeof(struct drm_color_ctm) * 2),
+ -EINVAL);
+ igt_assert_eq(pipe_set_property_blob_id(pipe, IGT_CRTC_CTM,
+ pipe->crtc_id), -EINVAL);
+ igt_assert_eq(pipe_set_property_blob_id(pipe, IGT_CRTC_CTM,
+ 4096 * 4096), -EINVAL);
+
+ free(ptr);
+}
+
+igt_main
+{
+ data_t data = {};
+ enum pipe pipe;
+
+ igt_fixture {
+ data.drm_fd = drm_open_driver_master(DRIVER_ANY);
+ if (is_i915_device(data.drm_fd))
+ data.devid = intel_get_drm_devid(data.drm_fd);
+ data.chamelium = chamelium_init(data.drm_fd);
+ igt_require(data.chamelium);
+
+ data.ports = chamelium_get_ports(data.chamelium,
+ &data.port_count);
+
+ kmstest_set_vt_graphics_mode();
+ igt_display_require(&data.display, data.drm_fd);
+ igt_require(data.display.is_atomic);
+ }
+
+ for_each_pipe_static(pipe)
+ igt_subtest_group
+ run_tests_for_pipe(&data, pipe);
+ igt_describe("Negative test case gamma lut size");
+ igt_subtest_f("pipe-invalid-gamma-lut-sizes")
+ invalid_gamma_lut_sizes(&data);
+
+ igt_describe("Negative test case degamma lut size");
+ igt_subtest_f("pipe-invalid-degamma-lut-sizes")
+ invalid_degamma_lut_sizes(&data);
+
+ igt_describe("Negative test case ctm matrix size");
+ igt_subtest_f("pipe-invalid-ctm-matrix-sizes")
+ invalid_ctm_matrix_sizes(&data);
+
+ igt_fixture {
+ igt_display_fini(&data.display);
+ }
+}
diff --git a/tests/meson.build b/tests/meson.build
index 570de54..74a5541 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -256,6 +256,7 @@ endif
if chamelium.found()
test_progs += [
'kms_chamelium',
+ 'kms_color_chamelium',
]
test_deps += chamelium
endif
--
2.7.4
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev
^ permalink raw reply related [flat|nested] 6+ messages in thread
* [igt-dev] ✓ Fi.CI.BAT: success for validate color tests using chamelium.
2020-01-14 13:35 [igt-dev] [PATCH i-g-t 0/2] validate color tests using chamelium Kunal Joshi
2020-01-14 13:35 ` [igt-dev] [PATCH i-g-t 1/2] lib/igt_chamelium: add function to compare two frame dumps Kunal Joshi
2020-01-14 13:35 ` [igt-dev] [PATCH i-g-t 2/2] tests/kms_color_chamelium: add subtests to validate color Kunal Joshi
@ 2020-01-14 14:22 ` Patchwork
2020-01-16 16:26 ` [igt-dev] ✓ Fi.CI.IGT: " Patchwork
3 siblings, 0 replies; 6+ messages in thread
From: Patchwork @ 2020-01-14 14:22 UTC (permalink / raw)
To: Kunal Joshi; +Cc: igt-dev
== Series Details ==
Series: validate color tests using chamelium.
URL : https://patchwork.freedesktop.org/series/72006/
State : success
== Summary ==
CI Bug Log - changes from CI_DRM_7739 -> IGTPW_3922
====================================================
Summary
-------
**SUCCESS**
No regressions found.
External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/index.html
Known issues
------------
Here are the changes found in IGTPW_3922 that come from known issues:
### IGT changes ###
#### Issues hit ####
* igt@i915_module_load@reload-with-fault-injection:
- fi-skl-6700k2: [PASS][1] -> [DMESG-WARN][2] ([i915#889])
[1]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/fi-skl-6700k2/igt@i915_module_load@reload-with-fault-injection.html
[2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/fi-skl-6700k2/igt@i915_module_load@reload-with-fault-injection.html
* igt@i915_selftest@live_blt:
- fi-ivb-3770: [PASS][3] -> [DMESG-FAIL][4] ([i915#770])
[3]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/fi-ivb-3770/igt@i915_selftest@live_blt.html
[4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/fi-ivb-3770/igt@i915_selftest@live_blt.html
#### Possible fixes ####
* igt@gem_close_race@basic-threads:
- fi-byt-j1900: [TIMEOUT][5] ([fdo#112271] / [i915#816]) -> [PASS][6]
[5]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/fi-byt-j1900/igt@gem_close_race@basic-threads.html
[6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/fi-byt-j1900/igt@gem_close_race@basic-threads.html
* igt@gem_exec_fence@basic-wait-default:
- {fi-ehl-1}: [INCOMPLETE][7] ([i915#937]) -> [PASS][8]
[7]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/fi-ehl-1/igt@gem_exec_fence@basic-wait-default.html
[8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/fi-ehl-1/igt@gem_exec_fence@basic-wait-default.html
* igt@i915_module_load@reload-with-fault-injection:
- fi-skl-lmem: [INCOMPLETE][9] ([i915#671]) -> [PASS][10]
[9]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/fi-skl-lmem/igt@i915_module_load@reload-with-fault-injection.html
[10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/fi-skl-lmem/igt@i915_module_load@reload-with-fault-injection.html
* igt@i915_pm_rpm@module-reload:
- fi-skl-6770hq: [FAIL][11] ([i915#178]) -> [PASS][12]
[11]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/fi-skl-6770hq/igt@i915_pm_rpm@module-reload.html
[12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/fi-skl-6770hq/igt@i915_pm_rpm@module-reload.html
* igt@i915_selftest@live_blt:
- fi-hsw-4770: [DMESG-FAIL][13] ([i915#725]) -> [PASS][14]
[13]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/fi-hsw-4770/igt@i915_selftest@live_blt.html
[14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/fi-hsw-4770/igt@i915_selftest@live_blt.html
{name}: This element is suppressed. This means it is ignored when computing
the status of the difference (SUCCESS, WARNING, or FAILURE).
[fdo#112271]: https://bugs.freedesktop.org/show_bug.cgi?id=112271
[i915#178]: https://gitlab.freedesktop.org/drm/intel/issues/178
[i915#671]: https://gitlab.freedesktop.org/drm/intel/issues/671
[i915#725]: https://gitlab.freedesktop.org/drm/intel/issues/725
[i915#770]: https://gitlab.freedesktop.org/drm/intel/issues/770
[i915#816]: https://gitlab.freedesktop.org/drm/intel/issues/816
[i915#889]: https://gitlab.freedesktop.org/drm/intel/issues/889
[i915#937]: https://gitlab.freedesktop.org/drm/intel/issues/937
Participating hosts (53 -> 42)
------------------------------
Missing (11): fi-hsw-4770r fi-ilk-m540 fi-hsw-4200u fi-glk-dsi fi-byt-squawks fi-bsw-cyan fi-ilk-650 fi-ctg-p8600 fi-elk-e7500 fi-tgl-y fi-byt-clapper
Build changes
-------------
* CI: CI-20190529 -> None
* IGT: IGT_5365 -> IGTPW_3922
CI-20190529: 20190529
CI_DRM_7739: 757c25a357ea6e34d5eba9b6efee6f45e7961334 @ git://anongit.freedesktop.org/gfx-ci/linux
IGTPW_3922: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/index.html
IGT_5365: e9ec0ed63b25c86861ffac3c8601cc4d1b910b65 @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools
== Testlist changes ==
+igt@kms_color_chamelium@pipe-a-ctm-0-5
+igt@kms_color_chamelium@pipe-a-ctm-0-25
+igt@kms_color_chamelium@pipe-a-ctm-0-75
+igt@kms_color_chamelium@pipe-a-ctm-blue-to-red
+igt@kms_color_chamelium@pipe-a-ctm-green-to-red
+igt@kms_color_chamelium@pipe-a-ctm-limited-range
+igt@kms_color_chamelium@pipe-a-ctm-max
+igt@kms_color_chamelium@pipe-a-ctm-negative
+igt@kms_color_chamelium@pipe-a-ctm-red-to-blue
+igt@kms_color_chamelium@pipe-a-degamma
+igt@kms_color_chamelium@pipe-a-gamma
+igt@kms_color_chamelium@pipe-b-ctm-0-5
+igt@kms_color_chamelium@pipe-b-ctm-0-25
+igt@kms_color_chamelium@pipe-b-ctm-0-75
+igt@kms_color_chamelium@pipe-b-ctm-blue-to-red
+igt@kms_color_chamelium@pipe-b-ctm-green-to-red
+igt@kms_color_chamelium@pipe-b-ctm-limited-range
+igt@kms_color_chamelium@pipe-b-ctm-max
+igt@kms_color_chamelium@pipe-b-ctm-negative
+igt@kms_color_chamelium@pipe-b-ctm-red-to-blue
+igt@kms_color_chamelium@pipe-b-degamma
+igt@kms_color_chamelium@pipe-b-gamma
+igt@kms_color_chamelium@pipe-c-ctm-0-5
+igt@kms_color_chamelium@pipe-c-ctm-0-25
+igt@kms_color_chamelium@pipe-c-ctm-0-75
+igt@kms_color_chamelium@pipe-c-ctm-blue-to-red
+igt@kms_color_chamelium@pipe-c-ctm-green-to-red
+igt@kms_color_chamelium@pipe-c-ctm-limited-range
+igt@kms_color_chamelium@pipe-c-ctm-max
+igt@kms_color_chamelium@pipe-c-ctm-negative
+igt@kms_color_chamelium@pipe-c-ctm-red-to-blue
+igt@kms_color_chamelium@pipe-c-degamma
+igt@kms_color_chamelium@pipe-c-gamma
+igt@kms_color_chamelium@pipe-d-ctm-0-5
+igt@kms_color_chamelium@pipe-d-ctm-0-25
+igt@kms_color_chamelium@pipe-d-ctm-0-75
+igt@kms_color_chamelium@pipe-d-ctm-blue-to-red
+igt@kms_color_chamelium@pipe-d-ctm-green-to-red
+igt@kms_color_chamelium@pipe-d-ctm-limited-range
+igt@kms_color_chamelium@pipe-d-ctm-max
+igt@kms_color_chamelium@pipe-d-ctm-negative
+igt@kms_color_chamelium@pipe-d-ctm-red-to-blue
+igt@kms_color_chamelium@pipe-d-degamma
+igt@kms_color_chamelium@pipe-d-gamma
+igt@kms_color_chamelium@pipe-e-ctm-0-5
+igt@kms_color_chamelium@pipe-e-ctm-0-25
+igt@kms_color_chamelium@pipe-e-ctm-0-75
+igt@kms_color_chamelium@pipe-e-ctm-blue-to-red
+igt@kms_color_chamelium@pipe-e-ctm-green-to-red
+igt@kms_color_chamelium@pipe-e-ctm-limited-range
+igt@kms_color_chamelium@pipe-e-ctm-max
+igt@kms_color_chamelium@pipe-e-ctm-negative
+igt@kms_color_chamelium@pipe-e-ctm-red-to-blue
+igt@kms_color_chamelium@pipe-e-degamma
+igt@kms_color_chamelium@pipe-e-gamma
+igt@kms_color_chamelium@pipe-f-ctm-0-5
+igt@kms_color_chamelium@pipe-f-ctm-0-25
+igt@kms_color_chamelium@pipe-f-ctm-0-75
+igt@kms_color_chamelium@pipe-f-ctm-blue-to-red
+igt@kms_color_chamelium@pipe-f-ctm-green-to-red
+igt@kms_color_chamelium@pipe-f-ctm-limited-range
+igt@kms_color_chamelium@pipe-f-ctm-max
+igt@kms_color_chamelium@pipe-f-ctm-negative
+igt@kms_color_chamelium@pipe-f-ctm-red-to-blue
+igt@kms_color_chamelium@pipe-f-degamma
+igt@kms_color_chamelium@pipe-f-gamma
+igt@kms_color_chamelium@pipe-invalid-ctm-matrix-sizes
+igt@kms_color_chamelium@pipe-invalid-degamma-lut-sizes
+igt@kms_color_chamelium@pipe-invalid-gamma-lut-sizes
== Logs ==
For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/index.html
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [igt-dev] [PATCH i-g-t 2/2] tests/kms_color_chamelium: add subtests to validate color.
2020-01-14 13:35 ` [igt-dev] [PATCH i-g-t 2/2] tests/kms_color_chamelium: add subtests to validate color Kunal Joshi
@ 2020-01-15 9:59 ` Arkadiusz Hiler
0 siblings, 0 replies; 6+ messages in thread
From: Arkadiusz Hiler @ 2020-01-15 9:59 UTC (permalink / raw)
To: Kunal Joshi; +Cc: ville.syrjala, petri.latvala, igt-dev, daniel.vetter
On Tue, Jan 14, 2020 at 07:05:04PM +0530, Kunal Joshi wrote:
> To validate color subtests using chamelium, subtests modified
> to do frame dump comparison instead of crc comparison.
> Tests require chamelium and will validate color features
> at pipe level.
>
> Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
> Signed-off-by: Swati Sharma <swati2.sharma@intel.com>
> Suggested-by: Uma Shankar <uma.shankar@intel.com>
> ---
> tests/Makefile.am | 1 +
> tests/kms_color_chamelium.c | 1119 +++++++++++++++++++++++++++++++++++++++++++
> tests/meson.build | 1 +
> 3 files changed, 1121 insertions(+)
> create mode 100644 tests/kms_color_chamelium.c
>
> diff --git a/tests/Makefile.am b/tests/Makefile.am
> index 9a320bc..1794569 100644
> --- a/tests/Makefile.am
> +++ b/tests/Makefile.am
> @@ -13,6 +13,7 @@ endif
> if HAVE_CHAMELIUM
> TESTS_progs += \
> kms_chamelium \
> + kms_color_chamelium \
> $(NULL)
> endif
>
> diff --git a/tests/kms_color_chamelium.c b/tests/kms_color_chamelium.c
> new file mode 100644
> index 0000000..0c87bf5
> --- /dev/null
> +++ b/tests/kms_color_chamelium.c
> @@ -0,0 +1,1119 @@
> +/*
> + * Copyright © 2020 Intel Corporation
> + *
> + * 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 (including the next
> + * paragraph) 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.
> + *
> + */
> +
> +#include <math.h>
> +#include <unistd.h>
> +
> +#include "drm.h"
> +#include "drmtest.h"
> +#include "igt.h"
> +
> +IGT_TEST_DESCRIPTION("Test Color Features at Pipe level");
> +
> +/* Internal */
> +typedef struct {
> + double r, g, b;
> +} color_t;
> +
> +typedef struct {
> + int drm_fd;
> + uint32_t devid;
> + igt_display_t display;
> +
> + uint32_t color_depth;
> + uint64_t degamma_lut_size;
> + uint64_t gamma_lut_size;
> +
> + struct chamelium *chamelium;
> + struct chamelium_port **ports;
> + int port_count;
> +} data_t;
> +
> +typedef struct {
> + int size;
> + double coeffs[];
> +} gamma_lut_t;
> +
> +static void paint_gradient_rectangles(data_t *data,
> + drmModeModeInfo *mode,
> + color_t *colors,
> + struct igt_fb *fb)
> +{
> + cairo_t *cr = igt_get_cairo_ctx(data->drm_fd, fb);
> + int i, l = mode->hdisplay / 3;
> + int rows_remaining = mode->hdisplay % 3;
> +
> + /* Paint 3 gradient rectangles with red/green/blue between 1.0 and
> + * 0.5. We want to avoid 0 so each max LUTs only affect their own
> + * rectangle.
> + */
> + for (i = 0 ; i < 3; i++) {
> + igt_paint_color_gradient_range(cr, i * l, 0, l, mode->vdisplay,
> + colors[i].r != 0 ? 0.2 : 0,
> + colors[i].g != 0 ? 0.2 : 0,
> + colors[i].b != 0 ? 0.2 : 0,
> + colors[i].r,
> + colors[i].g,
> + colors[i].b);
> + }
> +
> + if (rows_remaining > 0)
> + igt_paint_color_gradient_range(cr, i * l, 0, rows_remaining,
> + mode->vdisplay,
> + colors[i-1].r != 0 ? 0.2 : 0,
> + colors[i-1].g != 0 ? 0.2 : 0,
> + colors[i-1].b != 0 ? 0.2 : 0,
> + colors[i-1].r,
> + colors[i-1].g,
> + colors[i-1].b);
> +
> + igt_put_cairo_ctx(data->drm_fd, fb, cr);
> +}
> +
> +static void paint_rectangles(data_t *data,
> + drmModeModeInfo *mode,
> + color_t *colors,
> + struct igt_fb *fb)
> +{
> + cairo_t *cr = igt_get_cairo_ctx(data->drm_fd, fb);
> + int i, l = mode->hdisplay / 3;
> + int rows_remaining = mode->hdisplay % 3;
> +
> + /* Paint 3 solid rectangles. */
> + for (i = 0 ; i < 3; i++) {
> + igt_paint_color(cr, i * l, 0, l, mode->vdisplay,
> + colors[i].r, colors[i].g, colors[i].b);
> + }
> +
> + if (rows_remaining > 0)
> + igt_paint_color(cr, i * l, 0, rows_remaining, mode->vdisplay,
> + colors[i-1].r, colors[i-1].g, colors[i-1].b);
> +
> + igt_put_cairo_ctx(data->drm_fd, fb, cr);
> +}
> +
> +static gamma_lut_t *alloc_lut(int lut_size)
> +{
> + gamma_lut_t *gamma;
> +
> + igt_assert_lt(0, lut_size);
> +
> + gamma = malloc(sizeof(*gamma) + lut_size * sizeof(gamma->coeffs[0]));
> + igt_assert(gamma);
> + gamma->size = lut_size;
> +
> + return gamma;
> +}
> +
> +static void free_lut(gamma_lut_t *gamma)
> +{
> + if (!gamma)
> + return;
> +
> + free(gamma);
> +}
> +
> +static gamma_lut_t *generate_table(int lut_size, double exp)
> +{
> + gamma_lut_t *gamma = alloc_lut(lut_size);
> + int i;
> +
> + gamma->coeffs[0] = 0.0;
> + for (i = 1; i < lut_size; i++)
> + gamma->coeffs[i] = pow(i * 1.0 / (lut_size - 1), exp);
> +
> + return gamma;
> +}
> +
> +static gamma_lut_t *generate_table_max(int lut_size)
> +{
> + gamma_lut_t *gamma = alloc_lut(lut_size);
> + int i;
> +
> + gamma->coeffs[0] = 0.0;
> + for (i = 1; i < lut_size; i++)
> + gamma->coeffs[i] = 1.0;
> +
> + return gamma;
> +}
> +
> +static struct drm_color_lut *coeffs_to_lut(data_t *data,
> + const gamma_lut_t *gamma,
> + uint32_t color_depth,
> + int off)
> +{
> + struct drm_color_lut *lut;
> + int i, lut_size = gamma->size;
> + uint32_t max_value = (1 << 16) - 1;
> + uint32_t mask;
> +
> + if (is_i915_device(data->drm_fd))
> + mask = ((1 << color_depth) - 1) << 8;
> + else
> + mask = max_value;
> +
> + lut = malloc(sizeof(struct drm_color_lut) * lut_size);
> +
> + if (IS_CHERRYVIEW(data->devid))
> + lut_size -= 1;
> + for (i = 0; i < lut_size; i++) {
> + uint32_t v = (gamma->coeffs[i] * max_value);
> +
> + v &= mask;
> +
> + lut[i].red = v;
> + lut[i].green = v;
> + lut[i].blue = v;
> + }
> +
> + if (IS_CHERRYVIEW(data->devid))
> + lut[lut_size].red =
> + lut[lut_size].green =
> + lut[lut_size].blue = lut[lut_size - 1].red;
> +
> + return lut;
> +}
> +
> +static void set_degamma(data_t *data,
> + igt_pipe_t *pipe,
> + const gamma_lut_t *gamma)
> +{
> + size_t size = sizeof(struct drm_color_lut) * gamma->size;
> + struct drm_color_lut *lut = coeffs_to_lut(data, gamma,
> + data->color_depth, 0);
> +
> + free(lut);
> +}
> +
> +static void set_gamma(data_t *data,
> + igt_pipe_t *pipe,
> + const gamma_lut_t *gamma)
> +{
> + size_t size = sizeof(struct drm_color_lut) * gamma->size;
> + struct drm_color_lut *lut = coeffs_to_lut(data, gamma,
> + data->color_depth, 0);
> +
> + igt_pipe_obj_replace_prop_blob(pipe, IGT_CRTC_GAMMA_LUT, lut, size);
> +
> + free(lut);
> +}
> +
> +static void set_ctm(igt_pipe_t *pipe, const double *coefficients)
> +{
> + struct drm_color_ctm ctm;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(ctm.matrix); i++) {
> + if (coefficients[i] < 0) {
> + ctm.matrix[i] =
> + (int64_t) (-coefficients[i] *
> + ((int64_t) 1L << 32));
> + ctm.matrix[i] |= 1ULL << 63;
> + } else
> + ctm.matrix[i] =
> + (int64_t) (coefficients[i] *
> + ((int64_t) 1L << 32));
> + }
> +
> + igt_pipe_obj_replace_prop_blob(pipe, IGT_CRTC_CTM, &ctm, sizeof(ctm));
> +}
> +
> +static void disable_prop(igt_pipe_t *pipe, enum igt_atomic_crtc_properties prop)
> +{
> + if (igt_pipe_obj_has_prop(pipe, prop))
> + igt_pipe_obj_replace_prop_blob(pipe, prop, NULL, 0);
> +}
> +
> +#define disable_degamma(pipe) disable_prop(pipe, IGT_CRTC_DEGAMMA_LUT)
> +#define disable_gamma(pipe) disable_prop(pipe, IGT_CRTC_GAMMA_LUT)
> +#define disable_ctm(pipe) disable_prop(pipe, IGT_CRTC_CTM)
> +
> +/*
> + * Draw 3 gradient rectangles in red, green and blue, with a maxed out
> + * degamma LUT and verify we have the same frame dump as drawing solid color
> + * rectangles with linear degamma LUT.
> + */
> +static void test_pipe_degamma(data_t *data,
> + igt_plane_t *primary)
> +{
> + igt_output_t *output;
> + gamma_lut_t *degamma_linear, *degamma_full;
> + gamma_lut_t *gamma_linear;
> + color_t red_green_blue[] = {
> + { 1.0, 0.0, 0.0 },
> + { 0.0, 1.0, 0.0 },
> + { 0.0, 0.0, 1.0 }
> + };
> +
> + int i;
> + struct chamelium_port *port;
> + char *connected_ports[4];
> + bool valid_output = false;
> +
> + for (i = 0; i < data->port_count; i++)
> + connected_ports[i] =
> + (char *) chamelium_port_get_name(data->ports[i]);
> +
> + igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_DEGAMMA_LUT));
> + igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_GAMMA_LUT));
> +
> + degamma_linear = generate_table(data->degamma_lut_size, 1.0);
> + degamma_full = generate_table_max(data->degamma_lut_size);
> +
> + gamma_linear = generate_table(data->gamma_lut_size, 1.0);
> +
> + for_each_valid_output_on_pipe(&data->display,
> + primary->pipe->pipe,
> + output) {
> + drmModeModeInfo *mode;
> + struct igt_fb fb_modeset, fb;
> + struct chamelium_frame_dump *frame_fullgamma, *frame_fullcolors;
> + int fb_id, fb_modeset_id;
> +
> + for (i = 0; i < data->port_count; i++)
> + valid_output |=
> + (strcmp(output->name, connected_ports[i]) == 0);
> + if (!valid_output)
> + continue;
> + else
> + for (i = 0; i < data->port_count; i++)
> + if (strcmp(output->name,
> + connected_ports[i]) == 0)
> + port = data->ports[i];
> +
> + igt_output_set_pipe(output, primary->pipe->pipe);
> + mode = igt_output_get_mode(output);
> +
> + /* Create a framebuffer at the size of the output. */
> + fb_id = igt_create_fb(data->drm_fd,
> + mode->hdisplay,
> + mode->vdisplay,
> + DRM_FORMAT_XRGB8888,
> + LOCAL_DRM_FORMAT_MOD_NONE,
> + &fb);
> + igt_assert(fb_id);
> +
> + fb_modeset_id = igt_create_fb(data->drm_fd,
> + mode->hdisplay,
> + mode->vdisplay,
> + DRM_FORMAT_XRGB8888,
> + LOCAL_DRM_FORMAT_MOD_NONE,
> + &fb_modeset);
> + igt_assert(fb_modeset_id);
> +
> + igt_plane_set_fb(primary, &fb_modeset);
> + disable_ctm(primary->pipe);
> + disable_degamma(primary->pipe);
> + set_gamma(data, primary->pipe, gamma_linear);
> + igt_display_commit(&data->display);
> +
> + /* Draw solid colors with no degamma transformation. */
> + paint_rectangles(data, mode, red_green_blue, &fb);
> + igt_plane_set_fb(primary, &fb);
> + igt_display_commit(&data->display);
> + chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
> + frame_fullgamma =
> + chamelium_read_captured_frame(data->chamelium, 0);
> +
> + /* Draw a gradient with degamma LUT to remap all
> + * values to max red/green/blue.
> + */
> + paint_gradient_rectangles(data, mode, red_green_blue, &fb);
> + igt_plane_set_fb(primary, &fb);
> + set_degamma(data, primary->pipe, degamma_full);
> + igt_display_commit(&data->display);
> + chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
> + frame_fullcolors =
> + chamelium_read_captured_frame(data->chamelium, 0);
> +
> + /* Verify that the frame dump of the software computed output
> + * is equal to the frame dump of the degamma LUT transformation
> + * output.
> + */
> + igt_assert(chamelium_assert_frame_dump_eq(data->chamelium,
> + frame_fullgamma,
> + frame_fullcolors));
> +
> + igt_plane_set_fb(primary, NULL);
> + igt_output_set_pipe(output, PIPE_NONE);
> + }
> +
> + free_lut(degamma_linear);
> + free_lut(degamma_full);
> + free_lut(gamma_linear);
> +}
> +
> +/*
> + * Draw 3 gradient rectangles in red, green and blue, with a maxed out
> + * gamma LUT and verify we have the same frame dump as drawing solid
> + * color rectangles.
> + */
> +static void test_pipe_gamma(data_t *data,
> + igt_plane_t *primary)
> +{
> + igt_output_t *output;
> + gamma_lut_t *gamma_full;
> + color_t red_green_blue[] = {
> + { 1.0, 0.0, 0.0 },
> + { 0.0, 1.0, 0.0 },
> + { 0.0, 0.0, 1.0 }
> + };
> +
> + int i;
> + struct chamelium_port *port;
> + char *connected_ports[4];
> + bool valid_output = false;
> +
> + for (i = 0; i < data->port_count; i++)
> + connected_ports[i] =
> + (char *) chamelium_port_get_name(data->ports[i]);
> +
> + igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_GAMMA_LUT));
> +
> + gamma_full = generate_table_max(data->gamma_lut_size);
> +
> + for_each_valid_output_on_pipe(&data->display,
> + primary->pipe->pipe,
> + output) {
> + drmModeModeInfo *mode;
> + struct igt_fb fb_modeset, fb;
> + struct chamelium_frame_dump *frame_fullgamma, *frame_fullcolors;
> + int fb_id, fb_modeset_id;
> +
> + for (i = 0; i < data->port_count; i++)
> + valid_output |=
> + (strcmp(output->name, connected_ports[i]) == 0);
> + if (!valid_output)
> + continue;
> + else
> + for (i = 0; i < data->port_count; i++)
> + if (strcmp(output->name,
> + connected_ports[i]) == 0)
> + port = data->ports[i];
> +
> + igt_output_set_pipe(output, primary->pipe->pipe);
> + mode = igt_output_get_mode(output);
> +
> + /* Create a framebuffer at the size of the output. */
> + fb_id = igt_create_fb(data->drm_fd,
> + mode->hdisplay,
> + mode->vdisplay,
> + DRM_FORMAT_XRGB8888,
> + LOCAL_DRM_FORMAT_MOD_NONE,
> + &fb);
> + igt_assert(fb_id);
> +
> + fb_modeset_id = igt_create_fb(data->drm_fd,
> + mode->hdisplay,
> + mode->vdisplay,
> + DRM_FORMAT_XRGB8888,
> + LOCAL_DRM_FORMAT_MOD_NONE,
> + &fb_modeset);
> + igt_assert(fb_modeset_id);
> +
> + igt_plane_set_fb(primary, &fb_modeset);
> + disable_ctm(primary->pipe);
> + disable_degamma(primary->pipe);
> + set_gamma(data, primary->pipe, gamma_full);
> + igt_display_commit(&data->display);
> +
> + /* Draw solid colors with no gamma transformation. */
> + paint_rectangles(data, mode, red_green_blue, &fb);
> + igt_plane_set_fb(primary, &fb);
> + igt_display_commit(&data->display);
> + chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
> + frame_fullgamma =
> + chamelium_read_captured_frame(data->chamelium, 0);
> +
> + /* Draw a gradient with gamma LUT to remap all values
> + * to max red/green/blue.
> + */
> + paint_gradient_rectangles(data, mode, red_green_blue, &fb);
> + igt_plane_set_fb(primary, &fb);
> + igt_display_commit(&data->display);
> + chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
> + frame_fullcolors =
> + chamelium_read_captured_frame(data->chamelium, 0);
> +
> + /* Verify that the frame dump of the software computed output is
> + * equal to the frame dump of the degamma LUT transformation
> + * output.
> + */
> + igt_assert(chamelium_assert_frame_dump_eq(data->chamelium,
> + frame_fullgamma,
> + frame_fullcolors));
Is there any practical reason that you are capturing two frames and then
compareing them in this way?
There's chamelium_assert_frame_match_or_dump() which you can use to
compare against a reference fb without the need to display it first.
The added bonus is that it handles a lot of edge cases for you and dumps
the frame in case of a mismatch.
--
Cheers,
Arek
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev
^ permalink raw reply [flat|nested] 6+ messages in thread
* [igt-dev] ✓ Fi.CI.IGT: success for validate color tests using chamelium.
2020-01-14 13:35 [igt-dev] [PATCH i-g-t 0/2] validate color tests using chamelium Kunal Joshi
` (2 preceding siblings ...)
2020-01-14 14:22 ` [igt-dev] ✓ Fi.CI.BAT: success for validate color tests using chamelium Patchwork
@ 2020-01-16 16:26 ` Patchwork
3 siblings, 0 replies; 6+ messages in thread
From: Patchwork @ 2020-01-16 16:26 UTC (permalink / raw)
To: Kunal Joshi; +Cc: igt-dev
== Series Details ==
Series: validate color tests using chamelium.
URL : https://patchwork.freedesktop.org/series/72006/
State : success
== Summary ==
CI Bug Log - changes from CI_DRM_7739_full -> IGTPW_3922_full
====================================================
Summary
-------
**SUCCESS**
No regressions found.
External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/index.html
Possible new issues
-------------------
Here are the unknown changes that may have been introduced in IGTPW_3922_full:
### IGT changes ###
#### Possible regressions ####
* {igt@kms_color_chamelium@pipe-d-ctm-red-to-blue} (NEW):
- shard-tglb: NOTRUN -> [SKIP][1] +27 similar issues
[1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-tglb5/igt@kms_color_chamelium@pipe-d-ctm-red-to-blue.html
New tests
---------
New tests have been introduced between CI_DRM_7739_full and IGTPW_3922_full:
### New IGT tests (47) ###
* igt@kms_color_chamelium@pipe-a-ctm-0-25:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-a-ctm-0-5:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-a-ctm-0-75:
- Statuses : 7 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-a-ctm-blue-to-red:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-a-ctm-green-to-red:
- Statuses : 5 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-a-ctm-limited-range:
- Statuses : 7 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-a-ctm-max:
- Statuses : 5 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-a-ctm-negative:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-a-ctm-red-to-blue:
- Statuses : 7 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-a-degamma:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-a-gamma:
- Statuses : 5 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-b-ctm-0-25:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-b-ctm-0-5:
- Statuses : 7 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-b-ctm-0-75:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-b-ctm-blue-to-red:
- Statuses : 7 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-b-ctm-green-to-red:
- Statuses : 7 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-b-ctm-limited-range:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-b-ctm-max:
- Statuses : 7 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-b-ctm-negative:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-b-ctm-red-to-blue:
- Statuses : 7 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-b-degamma:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-b-gamma:
- Statuses : 5 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-c-ctm-0-25:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-c-ctm-0-5:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-c-ctm-0-75:
- Statuses : 7 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-c-ctm-blue-to-red:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-c-ctm-green-to-red:
- Statuses : 7 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-c-ctm-limited-range:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-c-ctm-max:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-c-ctm-negative:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-c-ctm-red-to-blue:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-c-degamma:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-c-gamma:
- Statuses : 7 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-d-ctm-0-25:
- Statuses : 5 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-d-ctm-0-5:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-d-ctm-0-75:
- Statuses : 7 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-d-ctm-blue-to-red:
- Statuses : 5 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-d-ctm-green-to-red:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-d-ctm-limited-range:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-d-ctm-max:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-d-ctm-negative:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-d-ctm-red-to-blue:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-d-degamma:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-d-gamma:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-invalid-ctm-matrix-sizes:
- Statuses : 6 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-invalid-degamma-lut-sizes:
- Statuses : 4 skip(s)
- Exec time: [0.0] s
* igt@kms_color_chamelium@pipe-invalid-gamma-lut-sizes:
- Statuses : 7 skip(s)
- Exec time: [0.0] s
Known issues
------------
Here are the changes found in IGTPW_3922_full that come from known issues:
### IGT changes ###
#### Issues hit ####
* igt@gem_ctx_shared@exec-single-timeline-bsd:
- shard-iclb: [PASS][2] -> [SKIP][3] ([fdo#110841])
[2]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb8/igt@gem_ctx_shared@exec-single-timeline-bsd.html
[3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb1/igt@gem_ctx_shared@exec-single-timeline-bsd.html
* igt@gem_exec_create@basic:
- shard-tglb: [PASS][4] -> [INCOMPLETE][5] ([fdo#111736] / [i915#472])
[4]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-tglb7/igt@gem_exec_create@basic.html
[5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-tglb2/igt@gem_exec_create@basic.html
* igt@gem_exec_create@forked:
- shard-glk: [PASS][6] -> [TIMEOUT][7] ([fdo#112271] / [i915#940])
[6]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-glk9/igt@gem_exec_create@forked.html
[7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-glk5/igt@gem_exec_create@forked.html
* igt@gem_exec_schedule@independent-bsd2:
- shard-iclb: [PASS][8] -> [SKIP][9] ([fdo#109276]) +20 similar issues
[8]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb4/igt@gem_exec_schedule@independent-bsd2.html
[9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb8/igt@gem_exec_schedule@independent-bsd2.html
* igt@gem_exec_schedule@pi-common-bsd:
- shard-iclb: [PASS][10] -> [SKIP][11] ([i915#677])
[10]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb3/igt@gem_exec_schedule@pi-common-bsd.html
[11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb2/igt@gem_exec_schedule@pi-common-bsd.html
* igt@gem_exec_schedule@smoketest-blt:
- shard-tglb: [PASS][12] -> [INCOMPLETE][13] ([i915#470] / [i915#472])
[12]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-tglb5/igt@gem_exec_schedule@smoketest-blt.html
[13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-tglb6/igt@gem_exec_schedule@smoketest-blt.html
* igt@gem_exec_schedule@wide-bsd:
- shard-iclb: [PASS][14] -> [SKIP][15] ([fdo#112146]) +3 similar issues
[14]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb6/igt@gem_exec_schedule@wide-bsd.html
[15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb1/igt@gem_exec_schedule@wide-bsd.html
* igt@gem_exec_suspend@basic-s0:
- shard-tglb: [PASS][16] -> [INCOMPLETE][17] ([i915#472]) +1 similar issue
[16]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-tglb7/igt@gem_exec_suspend@basic-s0.html
[17]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-tglb3/igt@gem_exec_suspend@basic-s0.html
* igt@gem_persistent_relocs@forked-interruptible-thrashing:
- shard-kbl: [PASS][18] -> [TIMEOUT][19] ([fdo#112271])
[18]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-kbl2/igt@gem_persistent_relocs@forked-interruptible-thrashing.html
[19]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-kbl2/igt@gem_persistent_relocs@forked-interruptible-thrashing.html
* igt@gem_persistent_relocs@forked-thrash-inactive:
- shard-tglb: [PASS][20] -> [TIMEOUT][21] ([fdo#112271] / [i915#530])
[20]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-tglb3/igt@gem_persistent_relocs@forked-thrash-inactive.html
[21]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-tglb5/igt@gem_persistent_relocs@forked-thrash-inactive.html
* igt@gem_sync@basic-each:
- shard-tglb: [PASS][22] -> [INCOMPLETE][23] ([i915#472] / [i915#707])
[22]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-tglb7/igt@gem_sync@basic-each.html
[23]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-tglb3/igt@gem_sync@basic-each.html
* igt@gen9_exec_parse@allowed-all:
- shard-glk: [PASS][24] -> [DMESG-WARN][25] ([i915#716])
[24]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-glk7/igt@gen9_exec_parse@allowed-all.html
[25]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-glk5/igt@gen9_exec_parse@allowed-all.html
* igt@i915_pm_dc@dc6-psr:
- shard-iclb: [PASS][26] -> [FAIL][27] ([i915#454])
[26]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb1/igt@i915_pm_dc@dc6-psr.html
[27]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb8/igt@i915_pm_dc@dc6-psr.html
* igt@i915_pm_rps@waitboost:
- shard-iclb: [PASS][28] -> [FAIL][29] ([i915#413])
[28]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb1/igt@i915_pm_rps@waitboost.html
[29]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb6/igt@i915_pm_rps@waitboost.html
* igt@kms_cursor_legacy@cursor-vs-flip-legacy:
- shard-tglb: [PASS][30] -> [INCOMPLETE][31] ([i915#519])
[30]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-tglb4/igt@kms_cursor_legacy@cursor-vs-flip-legacy.html
[31]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-tglb9/igt@kms_cursor_legacy@cursor-vs-flip-legacy.html
* igt@kms_frontbuffer_tracking@fbc-suspend:
- shard-kbl: [PASS][32] -> [DMESG-WARN][33] ([i915#180]) +4 similar issues
[32]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-kbl2/igt@kms_frontbuffer_tracking@fbc-suspend.html
[33]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-kbl6/igt@kms_frontbuffer_tracking@fbc-suspend.html
* igt@kms_frontbuffer_tracking@fbcpsr-1p-pri-indfb-multidraw:
- shard-tglb: [PASS][34] -> [FAIL][35] ([i915#49]) +2 similar issues
[34]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-tglb4/igt@kms_frontbuffer_tracking@fbcpsr-1p-pri-indfb-multidraw.html
[35]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-tglb1/igt@kms_frontbuffer_tracking@fbcpsr-1p-pri-indfb-multidraw.html
* igt@kms_plane@plane-panning-bottom-right-suspend-pipe-b-planes:
- shard-apl: [PASS][36] -> [DMESG-WARN][37] ([i915#180]) +2 similar issues
[36]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-apl8/igt@kms_plane@plane-panning-bottom-right-suspend-pipe-b-planes.html
[37]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-apl1/igt@kms_plane@plane-panning-bottom-right-suspend-pipe-b-planes.html
* igt@kms_psr@psr2_sprite_mmap_gtt:
- shard-iclb: [PASS][38] -> [SKIP][39] ([fdo#109441]) +3 similar issues
[38]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb2/igt@kms_psr@psr2_sprite_mmap_gtt.html
[39]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb5/igt@kms_psr@psr2_sprite_mmap_gtt.html
* igt@perf_pmu@init-busy-vcs1:
- shard-iclb: [PASS][40] -> [SKIP][41] ([fdo#112080]) +6 similar issues
[40]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb1/igt@perf_pmu@init-busy-vcs1.html
[41]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb8/igt@perf_pmu@init-busy-vcs1.html
#### Possible fixes ####
* igt@gem_ctx_isolation@vcs1-clean:
- shard-iclb: [SKIP][42] ([fdo#109276] / [fdo#112080]) -> [PASS][43] +2 similar issues
[42]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb3/igt@gem_ctx_isolation@vcs1-clean.html
[43]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb2/igt@gem_ctx_isolation@vcs1-clean.html
* igt@gem_exec_schedule@pi-distinct-iova-bsd:
- shard-iclb: [SKIP][44] ([i915#677]) -> [PASS][45]
[44]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb1/igt@gem_exec_schedule@pi-distinct-iova-bsd.html
[45]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb6/igt@gem_exec_schedule@pi-distinct-iova-bsd.html
* igt@gem_exec_schedule@preempt-other-chain-bsd:
- shard-iclb: [SKIP][46] ([fdo#112146]) -> [PASS][47] +6 similar issues
[46]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb1/igt@gem_exec_schedule@preempt-other-chain-bsd.html
[47]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb3/igt@gem_exec_schedule@preempt-other-chain-bsd.html
* igt@gem_exec_schedule@preempt-queue-contexts-render:
- shard-tglb: [INCOMPLETE][48] ([fdo#111606] / [fdo#111677] / [i915#472]) -> [PASS][49] +1 similar issue
[48]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-tglb8/igt@gem_exec_schedule@preempt-queue-contexts-render.html
[49]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-tglb1/igt@gem_exec_schedule@preempt-queue-contexts-render.html
* igt@gem_exec_schedule@smoketest-bsd2:
- shard-tglb: [INCOMPLETE][50] ([i915#472] / [i915#707]) -> [PASS][51] +1 similar issue
[50]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-tglb6/igt@gem_exec_schedule@smoketest-bsd2.html
[51]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-tglb1/igt@gem_exec_schedule@smoketest-bsd2.html
* igt@gem_persistent_relocs@forked-interruptible-thrashing:
- shard-hsw: [TIMEOUT][52] ([fdo#112271] / [i915#530]) -> [PASS][53]
[52]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-hsw2/igt@gem_persistent_relocs@forked-interruptible-thrashing.html
[53]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-hsw7/igt@gem_persistent_relocs@forked-interruptible-thrashing.html
* igt@gem_ppgtt@flink-and-close-vma-leak:
- shard-glk: [FAIL][54] ([i915#644]) -> [PASS][55]
[54]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-glk2/igt@gem_ppgtt@flink-and-close-vma-leak.html
[55]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-glk4/igt@gem_ppgtt@flink-and-close-vma-leak.html
- shard-apl: [FAIL][56] ([i915#644]) -> [PASS][57]
[56]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-apl1/igt@gem_ppgtt@flink-and-close-vma-leak.html
[57]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-apl6/igt@gem_ppgtt@flink-and-close-vma-leak.html
* igt@gen9_exec_parse@allowed-all:
- shard-kbl: [DMESG-WARN][58] ([i915#716]) -> [PASS][59]
[58]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-kbl7/igt@gen9_exec_parse@allowed-all.html
[59]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-kbl7/igt@gen9_exec_parse@allowed-all.html
* igt@i915_pm_dc@dc5-dpms:
- shard-iclb: [FAIL][60] ([i915#447]) -> [PASS][61]
[60]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb3/igt@i915_pm_dc@dc5-dpms.html
[61]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb1/igt@i915_pm_dc@dc5-dpms.html
* igt@i915_pm_rps@reset:
- shard-iclb: [FAIL][62] ([i915#413]) -> [PASS][63]
[62]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb2/igt@i915_pm_rps@reset.html
[63]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb2/igt@i915_pm_rps@reset.html
* igt@i915_suspend@sysfs-reader:
- shard-apl: [DMESG-WARN][64] ([i915#180]) -> [PASS][65] +3 similar issues
[64]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-apl6/igt@i915_suspend@sysfs-reader.html
[65]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-apl6/igt@i915_suspend@sysfs-reader.html
* igt@kms_cursor_crc@pipe-a-cursor-suspend:
- shard-kbl: [DMESG-WARN][66] ([i915#180]) -> [PASS][67] +10 similar issues
[66]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-kbl2/igt@kms_cursor_crc@pipe-a-cursor-suspend.html
[67]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-kbl7/igt@kms_cursor_crc@pipe-a-cursor-suspend.html
* igt@kms_cursor_legacy@2x-long-flip-vs-cursor-atomic:
- shard-glk: [FAIL][68] ([i915#72]) -> [PASS][69]
[68]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-glk8/igt@kms_cursor_legacy@2x-long-flip-vs-cursor-atomic.html
[69]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-glk2/igt@kms_cursor_legacy@2x-long-flip-vs-cursor-atomic.html
* igt@kms_flip@flip-vs-expired-vblank:
- shard-glk: [FAIL][70] ([i915#79]) -> [PASS][71]
[70]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-glk3/igt@kms_flip@flip-vs-expired-vblank.html
[71]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-glk3/igt@kms_flip@flip-vs-expired-vblank.html
* igt@kms_flip@flip-vs-suspend-interruptible:
- shard-apl: [INCOMPLETE][72] ([fdo#103927]) -> [PASS][73]
[72]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-apl6/igt@kms_flip@flip-vs-suspend-interruptible.html
[73]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-apl7/igt@kms_flip@flip-vs-suspend-interruptible.html
* igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-shrfb-draw-pwrite:
- shard-tglb: [FAIL][74] ([i915#49]) -> [PASS][75]
[74]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-tglb1/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-shrfb-draw-pwrite.html
[75]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-tglb5/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-shrfb-draw-pwrite.html
* igt@kms_plane@pixel-format-pipe-c-planes-source-clamping:
- shard-tglb: [FAIL][76] ([i915#576] / [i915#598]) -> [PASS][77]
[76]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-tglb5/igt@kms_plane@pixel-format-pipe-c-planes-source-clamping.html
[77]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-tglb1/igt@kms_plane@pixel-format-pipe-c-planes-source-clamping.html
- shard-iclb: [FAIL][78] ([i915#576]) -> [PASS][79]
[78]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb4/igt@kms_plane@pixel-format-pipe-c-planes-source-clamping.html
[79]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb4/igt@kms_plane@pixel-format-pipe-c-planes-source-clamping.html
* igt@kms_psr@psr2_sprite_blt:
- shard-iclb: [SKIP][80] ([fdo#109441]) -> [PASS][81] +1 similar issue
[80]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb1/igt@kms_psr@psr2_sprite_blt.html
[81]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb2/igt@kms_psr@psr2_sprite_blt.html
* igt@kms_vblank@pipe-c-ts-continuation-suspend:
- shard-kbl: [INCOMPLETE][82] ([fdo#103665]) -> [PASS][83]
[82]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-kbl4/igt@kms_vblank@pipe-c-ts-continuation-suspend.html
[83]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-kbl7/igt@kms_vblank@pipe-c-ts-continuation-suspend.html
* igt@perf_pmu@busy-no-semaphores-vcs1:
- shard-iclb: [SKIP][84] ([fdo#112080]) -> [PASS][85] +6 similar issues
[84]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb5/igt@perf_pmu@busy-no-semaphores-vcs1.html
[85]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb1/igt@perf_pmu@busy-no-semaphores-vcs1.html
* igt@prime_vgem@fence-wait-bsd2:
- shard-iclb: [SKIP][86] ([fdo#109276]) -> [PASS][87] +15 similar issues
[86]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-iclb5/igt@prime_vgem@fence-wait-bsd2.html
[87]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-iclb4/igt@prime_vgem@fence-wait-bsd2.html
#### Warnings ####
* igt@i915_pm_rpm@i2c:
- shard-snb: [INCOMPLETE][88] ([i915#82]) -> [SKIP][89] ([fdo#109271])
[88]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-snb2/igt@i915_pm_rpm@i2c.html
[89]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-snb1/igt@i915_pm_rpm@i2c.html
* igt@kms_atomic_transition@6x-modeset-transitions-nonblocking-fencing:
- shard-tglb: [SKIP][90] ([fdo#112016] / [fdo#112021]) -> [SKIP][91] ([fdo#112021])
[90]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-tglb3/igt@kms_atomic_transition@6x-modeset-transitions-nonblocking-fencing.html
[91]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-tglb9/igt@kms_atomic_transition@6x-modeset-transitions-nonblocking-fencing.html
* igt@runner@aborted:
- shard-kbl: ([FAIL][92], [FAIL][93]) ([i915#716] / [i915#974]) -> [FAIL][94] ([i915#974])
[92]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-kbl2/igt@runner@aborted.html
[93]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_7739/shard-kbl7/igt@runner@aborted.html
[94]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/shard-kbl2/igt@runner@aborted.html
{name}: This element is suppressed. This means it is ignored when computing
the status of the difference (SUCCESS, WARNING, or FAILURE).
[fdo#103665]: https://bugs.freedesktop.org/show_bug.cgi?id=103665
[fdo#103927]: https://bugs.freedesktop.org/show_bug.cgi?id=103927
[fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
[fdo#109276]: https://bugs.freedesktop.org/show_bug.cgi?id=109276
[fdo#109441]: https://bugs.freedesktop.org/show_bug.cgi?id=109441
[fdo#110841]: https://bugs.freedesktop.org/show_bug.cgi?id=110841
[fdo#111606]: https://bugs.freedesktop.org/show_bug.cgi?id=111606
[fdo#111677]: https://bugs.freedesktop.org/show_bug.cgi?id=111677
[fdo#111736]: https://bugs.freedesktop.org/show_bug.cgi?id=111736
[fdo#112016]: https://bugs.freedesktop.org/show_bug.cgi?id=112016
[fdo#112021]: https://bugs.freedesktop.org/show_bug.cgi?id=112021
[fdo#112080]: https://bugs.freedesktop.org/show_bug.cgi?id=112080
[fdo#112146]: https://bugs.freedesktop.org/show_bug.cgi?id=112146
[fdo#112271]: https://bugs.freedesktop.org/show_bug.cgi?id=112271
[i915#180]: https://gitlab.freedesktop.org/drm/intel/issues/180
[i915#413]: https://gitlab.freedesktop.org/drm/intel/issues/413
[i915#447]: https://gitlab.freedesktop.org/drm/intel/issues/447
[i915#454]: https://gitlab.freedesktop.org/drm/intel/issues/454
[i915#470]: https://gitlab.freedesktop.org/drm/intel/issues/470
[i915#472]: https://gitlab.freedesktop.org/drm/intel/issues/472
[i915#49]: https://gitlab.freedesktop.org/drm/intel/issues/49
[i915#519]: https://gitlab.freedesktop.org/drm/intel/issues/519
[i915#530]: https://gitlab.freedesktop.org/drm/intel/issues/530
[i915#576]: https://gitlab.freedesktop.org/drm/intel/issues/576
[i915#598]: https://gitlab.freedesktop.org/drm/intel/issues/598
[i915#644]: https://gitlab.freedesktop.org/drm/intel/issues/644
[i915#677]: https://gitlab.freedesktop.org/drm/intel/issues/677
[i915#707]: https://gitlab.freedesktop.org/drm/intel/issues/707
[i915#716]: https://gitlab.freedesktop.org/drm/intel/issues/716
[i915#72]: https://gitlab.freedesktop.org/drm/intel/issues/72
[i915#79]: https://gitlab.freedesktop.org/drm/intel/issues/79
[i915#82]: https://gitlab.freedesktop.org/drm/intel/issues/82
[i915#940]: https://gitlab.freedesktop.org/drm/intel/issues/940
[i915#974]: https://gitlab.freedesktop.org/drm/intel/issues/974
Participating hosts (11 -> 8)
------------------------------
Missing (3): pig-snb-2600 pig-glk-j5005 pig-skl-6260u
Build changes
-------------
* CI: CI-20190529 -> None
* IGT: IGT_5365 -> IGTPW_3922
* Piglit: piglit_4509 -> None
CI-20190529: 20190529
CI_DRM_7739: 757c25a357ea6e34d5eba9b6efee6f45e7961334 @ git://anongit.freedesktop.org/gfx-ci/linux
IGTPW_3922: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/index.html
IGT_5365: e9ec0ed63b25c86861ffac3c8601cc4d1b910b65 @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools
piglit_4509: fdc5a4ca11124ab8413c7988896eec4c97336694 @ git://anongit.freedesktop.org/piglit
== Logs ==
For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_3922/index.html
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2020-01-16 16:26 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-01-14 13:35 [igt-dev] [PATCH i-g-t 0/2] validate color tests using chamelium Kunal Joshi
2020-01-14 13:35 ` [igt-dev] [PATCH i-g-t 1/2] lib/igt_chamelium: add function to compare two frame dumps Kunal Joshi
2020-01-14 13:35 ` [igt-dev] [PATCH i-g-t 2/2] tests/kms_color_chamelium: add subtests to validate color Kunal Joshi
2020-01-15 9:59 ` Arkadiusz Hiler
2020-01-14 14:22 ` [igt-dev] ✓ Fi.CI.BAT: success for validate color tests using chamelium Patchwork
2020-01-16 16:26 ` [igt-dev] ✓ Fi.CI.IGT: " Patchwork
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.