On Fri, Jul 15, 2016 at 03:00:59PM +0100, Lionel Landwerlin wrote:
> Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@xxxxxxxxx>
Do we have the time for those in the BAT budget?
-Daniel
> ---
> tests/Makefile.sources | 2 +-
> tests/kms_pipe_color.c | 1184 ------------------------------------------
> tests/kms_pipe_color_basic.c | 1184 ++++++++++++++++++++++++++++++++++++++++++
> 3 files changed, 1185 insertions(+), 1185 deletions(-)
> delete mode 100644 tests/kms_pipe_color.c
> create mode 100644 tests/kms_pipe_color_basic.c
>
> diff --git a/tests/Makefile.sources b/tests/Makefile.sources
> index 8a9a7ec..53afe3c 100644
> --- a/tests/Makefile.sources
> +++ b/tests/Makefile.sources
> @@ -98,7 +98,7 @@ TESTS_progs_M = \
> kms_legacy_colorkey \
> kms_mmio_vs_cs_flip \
> kms_pipe_b_c_ivb \
> - kms_pipe_color \
> + kms_pipe_color_basic \
> kms_pipe_crc_basic \
> kms_plane \
> kms_psr_sink_crc \
> diff --git a/tests/kms_pipe_color.c b/tests/kms_pipe_color.c
> deleted file mode 100644
> index 9f7ac7e..0000000
> --- a/tests/kms_pipe_color.c
> +++ /dev/null
> @@ -1,1184 +0,0 @@
> -/*
> - * Copyright © 2015 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");
> -
> -/* Data structures for gamma/degamma ramps & ctm matrix. */
> -struct _drm_color_ctm {
> - /* Transformation matrix in S31.32 format. */
> - __s64 matrix[9];
> -};
> -
> -struct _drm_color_lut {
> - /*
> - * Data is U0.16 fixed point format.
> - */
> - __u16 red;
> - __u16 green;
> - __u16 blue;
> - __u16 reserved;
> -};
> -
> -/* Internal */
> -typedef struct {
> - double r, g, b;
> -} color_t;
> -
> -typedef struct {
> - int drm_fd;
> - uint32_t devid;
> - igt_display_t display;
> - igt_pipe_crc_t *pipe_crc;
> -
> - uint32_t color_depth;
> - uint64_t degamma_lut_size;
> - uint64_t gamma_lut_size;
> -} data_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;
> -
> - /* 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);
> - }
> -
> - cairo_destroy(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;
> -
> - /* 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);
> - }
> -
> - cairo_destroy(cr);
> -}
> -
> -static double *generate_table(uint32_t lut_size, double exp)
> -{
> - double *coeffs = malloc(sizeof(double) * lut_size);
> - uint32_t i;
> -
> - for (i = 0; i < lut_size; i++)
> - coeffs[i] = powf((double) i * 1.0 / (double) (lut_size - 1), exp);
> -
> - return coeffs;
> -}
> -
> -static double *generate_table_max(uint32_t lut_size)
> -{
> - double *coeffs = malloc(sizeof(double) * lut_size);
> - uint32_t i;
> -
> - coeffs[0] = 0.0;
> - for (i = 1; i < lut_size; i++)
> - coeffs[i] = 1.0;
> -
> - return coeffs;
> -}
> -
> -static double *generate_table_zero(uint32_t lut_size)
> -{
> - double *coeffs = malloc(sizeof(double) * lut_size);
> - uint32_t i;
> -
> - for (i = 0; i < lut_size; i++)
> - coeffs[i] = 0.0;
> -
> - return coeffs;
> -}
> -
> -static struct _drm_color_lut *coeffs_to_lut(data_t *data,
> - const double *coefficients,
> - uint32_t lut_size,
> - uint32_t color_depth,
> - int off)
> -{
> - struct _drm_color_lut *lut;
> - uint32_t i;
> - uint32_t max_value = (1 << 16) - 1;
> - uint32_t mask = ((1 << color_depth) - 1) << 8;
> -
> - 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 = (coefficients[i] * max_value);
> -
> - /*
> - * Hardware might encode colors on a different number of bits
> - * than what is in our framebuffer (10 or 12bits for example).
> - * Mask the lower bits not provided by the framebuffer so we
> - * can do CRC comparisons.
> - */
> - 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 double *coefficients)
> -{
> - size_t size = sizeof(struct _drm_color_lut) * data->degamma_lut_size;
> - struct _drm_color_lut *lut = coeffs_to_lut(data,
> - coefficients,
> - data->degamma_lut_size,
> - data->color_depth, 0);
> -
> - igt_pipe_set_degamma_lut(pipe, lut, size);
> -
> - free(lut);
> -}
> -
> -static void set_gamma(data_t *data,
> - igt_pipe_t *pipe,
> - const double *coefficients)
> -{
> - size_t size = sizeof(struct _drm_color_lut) * data->gamma_lut_size;
> - struct _drm_color_lut *lut = coeffs_to_lut(data,
> - coefficients,
> - data->gamma_lut_size,
> - data->color_depth, 0);
> -
> - igt_pipe_set_gamma_lut(pipe, 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_set_ctm_matrix(pipe, &ctm, sizeof(ctm));
> -}
> -
> -#define disable_degamma(pipe) igt_pipe_set_degamma_lut(pipe, NULL, 0)
> -#define disable_gamma(pipe) igt_pipe_set_gamma_lut(pipe, NULL, 0)
> -#define disable_ctm(pipe) igt_pipe_set_ctm_matrix(pipe, NULL, 0)
> -
> -static void output_set_property_enum(igt_output_t *output,
> - const char *property,
> - const char *enum_value)
> -{
> - int i;
> - int32_t value = -1;
> - uint32_t prop_id;
> - drmModePropertyPtr prop;
> -
> - if (!kmstest_get_property(output->display->drm_fd,
> - output->id,
> - DRM_MODE_OBJECT_CONNECTOR,
> - property,
> - &prop_id, NULL, &prop))
> - return;
> -
> - igt_assert(prop->flags & DRM_MODE_PROP_ENUM);
> -
> - for (i = 0; i < prop->count_enums; i++) {
> - if (!strcmp(prop->enums[i].name, enum_value)) {
> - value = prop->enums[i].value;
> - break;
> - }
> - }
> - igt_assert_neq(value, -1);
> -
> - igt_assert_eq(drmModeObjectSetProperty(output->display->drm_fd,
> - output->id,
> - DRM_MODE_OBJECT_CONNECTOR,
> - prop_id, value), 0);
> -
> -
> - drmModeFreeProperty(prop);
> -}
> -
> -/*
> - * Draw 3 gradient rectangles in red, green and blue, with a maxed out
> - * degamma LUT and verify we have the same CRC 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;
> - double *degamma_linear, *degamma_full;
> - double *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 }
> - };
> -
> - 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_connected_output(&data->display, output) {
> - drmModeModeInfo *mode;
> - struct igt_fb fb_modeset, fb;
> - igt_crc_t crc_fullgamma, crc_fullcolors;
> - int fb_id, fb_modeset_id;
> -
> - 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);
> - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors);
> -
> - /* 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);
> - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma);
> -
> - /* Verify that the CRC of the software computed output is
> - * equal to the CRC of the degamma LUT transformation output.
> - */
> - igt_assert_crc_equal(&crc_fullgamma, &crc_fullcolors);
> -
> - igt_output_set_pipe(output, PIPE_ANY);
> - }
> -
> - free(degamma_linear);
> - free(degamma_full);
> - free(gamma_linear);
> -}
> -
> -/*
> - * Draw 3 gradient rectangles in red, green and blue, with a maxed out gamma
> - * LUT and verify we have the same CRC as drawing solid color rectangles.
> - */
> -static void test_pipe_gamma(data_t *data,
> - igt_plane_t *primary)
> -{
> - igt_output_t *output;
> - double *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 }
> - };
> -
> - gamma_full = generate_table_max(data->gamma_lut_size);
> -
> - for_each_connected_output(&data->display, output) {
> - drmModeModeInfo *mode;
> - struct igt_fb fb_modeset, fb;
> - igt_crc_t crc_fullgamma, crc_fullcolors;
> - int fb_id, fb_modeset_id;
> -
> - 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);
> - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors);
> -
> - /* 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);
> - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma);
> -
> - /* Verify that the CRC of the software computed output is
> - * equal to the CRC of the gamma LUT transformation output.
> - */
> - igt_assert_crc_equal(&crc_fullgamma, &crc_fullcolors);
> -
> - igt_output_set_pipe(output, PIPE_ANY);
> - }
> -
> - free(gamma_full);
> -}
> -
> -/*
> - * Draw 3 gradient rectangles in red, green and blue, with a maxed out legacy
> - * gamma LUT and verify we have the same CRC as drawing solid color rectangles
> - * with linear legacy gamma LUT.
> - */
> -static void test_pipe_legacy_gamma(data_t *data,
> - igt_plane_t *primary)
> -{
> - igt_output_t *output;
> - color_t red_green_blue[] = {
> - { 1.0, 0.0, 0.0 },
> - { 0.0, 1.0, 0.0 },
> - { 0.0, 0.0, 1.0 }
> - };
> - drmModeCrtc *kms_crtc;
> - uint32_t i, legacy_lut_size;
> - uint16_t *red_lut, *green_lut, *blue_lut;
> -
> - kms_crtc = drmModeGetCrtc(data->drm_fd, primary->pipe->crtc_id);
> - legacy_lut_size = kms_crtc->gamma_size;
> - drmModeFreeCrtc(kms_crtc);
> -
> - red_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
> - green_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
> - blue_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
> -
> - for_each_connected_output(&data->display, output) {
> - drmModeModeInfo *mode;
> - struct igt_fb fb_modeset, fb;
> - igt_crc_t crc_fullgamma, crc_fullcolors;
> - int fb_id, fb_modeset_id;
> -
> - 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_degamma(primary->pipe);
> - disable_gamma(primary->pipe);
> - disable_ctm(primary->pipe);
> - 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);
> - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors);
> -
> - /* 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);
> -
> - red_lut[0] = green_lut[0] = blue_lut[0] = 0;
> - for (i = 1; i < legacy_lut_size; i++)
> - red_lut[i] = green_lut[i] = blue_lut[i] = 0xffff;
> - igt_assert_eq(drmModeCrtcSetGamma(data->drm_fd, primary->pipe->crtc_id,
> - legacy_lut_size, red_lut, green_lut, blue_lut), 0);
> - igt_display_commit(&data->display);
> - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma);
> -
> - /* Verify that the CRC of the software computed output is
> - * equal to the CRC of the gamma LUT transformation output.
> - */
> - igt_assert_crc_equal(&crc_fullgamma, &crc_fullcolors);
> -
> - /* Reset output. */
> - for (i = 1; i < legacy_lut_size; i++)
> - red_lut[i] = green_lut[i] = blue_lut[i] = i << 8;
> -
> - igt_assert_eq(drmModeCrtcSetGamma(data->drm_fd, primary->pipe->crtc_id,
> - legacy_lut_size, red_lut, green_lut, blue_lut), 0);
> - igt_display_commit(&data->display);
> -
> - igt_output_set_pipe(output, PIPE_ANY);
> - }
> -
> - free(red_lut);
> - free(green_lut);
> - free(blue_lut);
> -}
> -
> -static drmModePropertyBlobPtr
> -get_blob(data_t *data, igt_pipe_t *pipe, const char *property_name)
> -{
> - uint64_t prop_value;
> - drmModePropertyPtr prop;
> - drmModePropertyBlobPtr blob;
> -
> - igt_assert(igt_pipe_get_property(pipe, property_name,
> - NULL, &prop_value, &prop));
> -
> - if (prop_value == 0)
> - return NULL;
> -
> - igt_assert(prop->flags & DRM_MODE_PROP_BLOB);
> - blob = drmModeGetPropertyBlob(data->drm_fd, prop_value);
> - drmModeFreeProperty(prop);
> -
> - return blob;
> -}
> -
> -/*
> - * Verify that setting the legacy gamma LUT resets the gamma LUT set
> - * through the GAMMA_LUT property.
> - */
> -static void test_pipe_legacy_gamma_reset(data_t *data,
> - igt_plane_t *primary)
> -{
> - const double ctm_identity[] = {
> - 1.0, 0.0, 0.0,
> - 0.0, 1.0, 0.0,
> - 0.0, 0.0, 1.0
> - };
> - drmModeCrtc *kms_crtc;
> - double *degamma_linear, *gamma_zero;
> - uint32_t i, legacy_lut_size;
> - uint16_t *red_lut, *green_lut, *blue_lut;
> - struct _drm_color_lut *lut;
> - drmModePropertyBlobPtr blob;
> - igt_output_t *output;
> -
> - degamma_linear = generate_table(data->degamma_lut_size, 1.0);
> - gamma_zero = generate_table_zero(data->gamma_lut_size);
> -
> - for_each_connected_output(&data->display, output) {
> - igt_output_set_pipe(output, primary->pipe->pipe);
> -
> - /* Ensure we have a clean state to start with. */
> - disable_degamma(primary->pipe);
> - disable_ctm(primary->pipe);
> - disable_gamma(primary->pipe);
> - igt_display_commit(&data->display);
> -
> - /* Set a degama & gamma LUT and a CTM using the
> - * properties and verify the content of the
> - * properties. */
> - set_degamma(data, primary->pipe, degamma_linear);
> - set_ctm(primary->pipe, ctm_identity);
> - set_gamma(data, primary->pipe, gamma_zero);
> - igt_display_commit(&data->display);
> -
> - blob = get_blob(data, primary->pipe, "DEGAMMA_LUT");
> - igt_assert(blob &&
> - blob->length == (sizeof(struct _drm_color_lut) *
> - data->degamma_lut_size));
> - drmModeFreePropertyBlob(blob);
> -
> - blob = get_blob(data, primary->pipe, "CTM");
> - igt_assert(blob &&
> - blob->length == sizeof(struct _drm_color_ctm));
> - drmModeFreePropertyBlob(blob);
> -
> - blob = get_blob(data, primary->pipe, "GAMMA_LUT");
> - igt_assert(blob &&
> - blob->length == (sizeof(struct _drm_color_lut) *
> - data->gamma_lut_size));
> - lut = (struct _drm_color_lut *) blob->data;
> - for (i = 0; i < data->gamma_lut_size; i++)
> - igt_assert(lut[i].red == 0 &&
> - lut[i].green == 0 &&
> - lut[i].blue == 0);
> - drmModeFreePropertyBlob(blob);
> -
> - /* Set a gamma LUT using the legacy ioctl and verify
> - * the content of the GAMMA_LUT property is changed
> - * and that CTM and DEGAMMA_LUT are empty. */
> - kms_crtc = drmModeGetCrtc(data->drm_fd, primary->pipe->crtc_id);
> - legacy_lut_size = kms_crtc->gamma_size;
> - drmModeFreeCrtc(kms_crtc);
> -
> - red_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
> - green_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
> - blue_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
> -
> - for (i = 0; i < legacy_lut_size; i++)
> - red_lut[i] = green_lut[i] = blue_lut[i] = 0xffff;
> -
> - igt_assert_eq(drmModeCrtcSetGamma(data->drm_fd,
> - primary->pipe->crtc_id,
> - legacy_lut_size,
> - red_lut, green_lut, blue_lut),
> - 0);
> - igt_display_commit(&data->display);
> -
> - igt_assert(get_blob(data, primary->pipe,
> - "DEGAMMA_LUT") == NULL);
> - igt_assert(get_blob(data, primary->pipe, "CTM") == NULL);
> -
> - blob = get_blob(data, primary->pipe, "GAMMA_LUT");
> - igt_assert(blob &&
> - blob->length == (sizeof(struct _drm_color_lut) *
> - legacy_lut_size));
> - lut = (struct _drm_color_lut *) blob->data;
> - for (i = 0; i < legacy_lut_size; i++)
> - igt_assert(lut[i].red == 0xffff &&
> - lut[i].green == 0xffff &&
> - lut[i].blue == 0xffff);
> - drmModeFreePropertyBlob(blob);
> -
> - igt_output_set_pipe(output, PIPE_ANY);
> - }
> -
> - free(degamma_linear);
> - free(gamma_zero);
> -}
> -
> -/*
> - * Draw 3 rectangles using before colors with the ctm matrix apply and verify
> - * the CRC 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
> - };
> - double *degamma_linear, *gamma_linear;
> - igt_output_t *output;
> - bool ret = true;
> -
> - degamma_linear = generate_table(data->degamma_lut_size, 1.0);
> - gamma_linear = generate_table(data->gamma_lut_size, 1.0);
> -
> - for_each_connected_output(&data->display, output) {
> - drmModeModeInfo *mode;
> - struct igt_fb fb_modeset, fb;
> - igt_crc_t crc_software, crc_hardware;
> - int fb_id, fb_modeset_id;
> -
> - 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);
> - 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);
> - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_software);
> -
> - /* 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);
> - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_hardware);
> -
> - /* Verify that the CRC of the software computed output is
> - * equal to the CRC of the CTM matrix transformation output.
> - */
> - ret &= igt_crc_equal(&crc_software, &crc_hardware);
> -
> - igt_output_set_pipe(output, PIPE_ANY);
> - }
> -
> - free(degamma_linear);
> - free(gamma_linear);
> -
> - return ret;
> -}
> -
> -/*
> - * Hardware computes CRC based on the number of bits it is working with (8,
> - * 10, 12, 16 bits), meaning with a framebuffer of 8bits per color will
> - * usually leave the remaining lower bits at 0.
> - *
> - * We're programming the gamma LUT in order to get rid of those lower bits so
> - * we can compare the CRC of a framebuffer without any transformation to a CRC
> - * with transformation applied and verify the CRCs match.
> - *
> - * This test is currently disabled as the CRC computed on Intel hardware seems
> - * to include data on the lower bits, this is preventing us to CRC checks.
> - */
> -#if 0
> -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 };
> - double *degamma_linear, *gamma_linear;
> - igt_output_t *output;
> -
> - degamma_linear = generate_table(data->degamma_lut_size, 1.0);
> - gamma_linear = generate_table(data->gamma_lut_size, 1.0);
> -
> - for_each_connected_output(&data->display, output) {
> - drmModeModeInfo *mode;
> - struct igt_fb fb_modeset, fb;
> - igt_crc_t crc_full, crc_limited;
> - int fb_id, fb_modeset_id;
> -
> - 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);
> -
> - output_set_property_enum(output, "Broadcast RGB", "Full");
> - paint_rectangles(data, mode, red_green_blue_limited, &fb);
> - igt_plane_set_fb(primary, &fb);
> - igt_display_commit(&data->display);
> - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_full);
> -
> - /* Set the output into limited range. */
> - output_set_property_enum(output, "Broadcast RGB", "Limited 16:235");
> - paint_rectangles(data, mode, red_green_blue_full, &fb);
> - igt_plane_set_fb(primary, &fb);
> - igt_display_commit(&data->display);
> - igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> - igt_pipe_crc_collect_crc(data->pipe_crc, &crc_limited);
> -
> - /* Verify that the CRC of the software computed output is
> - * equal to the CRC of the CTM matrix transformation output.
> - */
> - igt_assert_crc_equal(&crc_full, &crc_limited);
> -
> - igt_output_set_pipe(output, PIPE_ANY);
> - }
> -
> - free(gamma_linear);
> - free(degamma_linear);
> -}
> -#endif
> -
> -static void
> -run_tests_for_pipe(data_t *data, enum pipe p)
> -{
> - igt_output_t *output;
> - 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_pipe_crc();
> -
> - if (p >= data->display.n_pipes)
> - return;
> -
> - pipe = &data->display.pipes[p];
> - if (pipe->n_planes < IGT_PLANE_PRIMARY)
> - return;
> -
> - primary = &pipe->planes[IGT_PLANE_PRIMARY];
> -
> - data->pipe_crc = igt_pipe_crc_new(primary->pipe->pipe,
> - INTEL_PIPE_CRC_SOURCE_AUTO);
> -
> - igt_require(igt_pipe_get_property(&data->display.pipes[p],
> - "DEGAMMA_LUT_SIZE",
> - NULL,
> - &data->degamma_lut_size,
> - NULL));
> - igt_require(igt_pipe_get_property(&data->display.pipes[p],
> - "GAMMA_LUT_SIZE",
> - NULL,
> - &data->gamma_lut_size,
> - NULL));
> -
> - for_each_connected_output(&data->display, output)
> - output_set_property_enum(output, "Broadcast RGB", "Full");
> - }
> -
> - /* We assume an 8bits depth per color for degamma/gamma LUTs
> - * for CRC checks with framebuffer references. */
> - data->color_depth = 8;
> - delta = 1.0 / (1 << data->color_depth);
> -
> - igt_subtest_f("ctm-red-to-blue-pipe%d", 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_subtest_f("ctm-green-to-red-pipe%d", 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_subtest_f("ctm-blue-to-red-pipe%d", 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_subtest_f("ctm-0-25-pipe%d", 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_subtest_f("ctm-0-5-pipe%d", 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_subtest_f("ctm-0-75-pipe%d", 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_subtest_f("ctm-max-pipe%d", 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_subtest_f("ctm-negative-pipe%d", 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));
> - }
> -
> -#if 0
> - igt_subtest_f("ctm-limited-range-pipe%d", p)
> - test_pipe_limited_range_ctm(data, primary);
> -#endif
> -
> - igt_subtest_f("degamma-pipe%d", p)
> - test_pipe_degamma(data, primary);
> -
> - igt_subtest_f("gamma-pipe%d", p)
> - test_pipe_gamma(data, primary);
> -
> - igt_subtest_f("legacy-gamma-pipe%d", p)
> - test_pipe_legacy_gamma(data, primary);
> -
> - igt_subtest_f("legacy-gamma-reset-pipe%d", p)
> - test_pipe_legacy_gamma_reset(data, primary);
> -
> - igt_fixture {
> - for_each_connected_output(&data->display, output)
> - output_set_property_enum(output, "Broadcast RGB", "Full");
> -
> - disable_degamma(primary->pipe);
> - disable_gamma(primary->pipe);
> - disable_ctm(primary->pipe);
> - igt_display_commit(&data->display);
> -
> - igt_pipe_crc_free(data->pipe_crc);
> - data->pipe_crc = NULL;
> - }
> -}
> -
> -static int
> -pipe_set_property_blob_id(igt_pipe_t *pipe, const char *property, uint32_t blob_id)
> -{
> - uint32_t prop_id;
> -
> - igt_assert(kmstest_get_property(pipe->display->drm_fd,
> - pipe->crtc_id,
> - DRM_MODE_OBJECT_CRTC,
> - property,
> - &prop_id, NULL, NULL));
> -
> - return drmModeObjectSetProperty(pipe->display->drm_fd,
> - pipe->crtc_id,
> - DRM_MODE_OBJECT_CRTC,
> - prop_id, blob_id);
> -}
> -
> -static int
> -pipe_set_property_blob(igt_pipe_t *pipe, const char *property, void *ptr, size_t length)
> -{
> - int ret = 0;
> - uint32_t blob_id = 0;
> -
> - if (length > 0)
> - igt_assert_eq(drmModeCreatePropertyBlob(pipe->display->drm_fd,
> - ptr, length,
> - &blob_id), 0);
> -
> - ret = pipe_set_property_blob_id(pipe, property, blob_id);
> -
> - if (blob_id != 0)
> - igt_assert_eq(drmModeDestroyPropertyBlob(pipe->display->drm_fd, blob_id), 0);
> -
> - return ret;
> -}
> -
> -static void
> -invalid_lut_sizes(data_t *data)
> -{
> - igt_pipe_t *pipe = &data->display.pipes[0];
> - size_t degamma_lut_size = data->degamma_lut_size * sizeof(struct _drm_color_lut);
> - size_t gamma_lut_size = data->gamma_lut_size * sizeof(struct _drm_color_lut);
> -
> - struct _drm_color_lut *degamma_lut = malloc(data->degamma_lut_size * sizeof(struct _drm_color_lut) * 2);
> - struct _drm_color_lut *gamma_lut = malloc(data->gamma_lut_size * sizeof(struct _drm_color_lut) * 2);
> -
> - igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT",
> - degamma_lut, 1), -EINVAL);
> - igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT",
> - degamma_lut, degamma_lut_size + 1),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT",
> - degamma_lut, degamma_lut_size - 1),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT",
> - degamma_lut, degamma_lut_size + sizeof(struct _drm_color_lut)),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob_id(pipe, "DEGAMMA_LUT", pipe->crtc_id),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob_id(pipe, "DEGAMMA_LUT", 4096 * 4096),
> - -EINVAL);
> -
> - igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT",
> - gamma_lut, 1),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT",
> - gamma_lut, gamma_lut_size + 1),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT",
> - gamma_lut, gamma_lut_size - 1),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT",
> - gamma_lut, gamma_lut_size + sizeof(struct _drm_color_lut)),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob_id(pipe, "GAMMA_LUT", pipe->crtc_id),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob_id(pipe, "GAMMA_LUT", 4096 * 4096),
> - -EINVAL);
> -
> - free(degamma_lut);
> - free(gamma_lut);
> -}
> -
> -static void
> -invalid_ctm_matrix_sizes(data_t *data)
> -{
> - igt_pipe_t *pipe = &data->display.pipes[0];
> - void *ptr = malloc(sizeof(struct _drm_color_ctm) * 4);
> -
> - igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr, 1),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr,
> - sizeof(struct _drm_color_ctm) + 1),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr,
> - sizeof(struct _drm_color_ctm) - 1),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr,
> - sizeof(struct _drm_color_ctm) * 2),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob_id(pipe, "CTM", pipe->crtc_id),
> - -EINVAL);
> - igt_assert_eq(pipe_set_property_blob_id(pipe, "CTM", 4096 * 4096),
> - -EINVAL);
> -
> - free(ptr);
> -}
> -
> -igt_main
> -{
> - data_t data = {};
> -
> - igt_skip_on_simulation();
> -
> - igt_fixture {
> - data.drm_fd = drm_open_driver_master(DRIVER_INTEL);
> - data.devid = intel_get_drm_devid(data.drm_fd);
> - kmstest_set_vt_graphics_mode();
> -
> - igt_display_init(&data.display, data.drm_fd);
> - }
> -
> - for (int pipe = 0; pipe < I915_MAX_PIPES; pipe++)
> - run_tests_for_pipe(&data, pipe);
> -
> - igt_subtest_f("invalid-lut-sizes")
> - invalid_lut_sizes(&data);
> -
> - igt_subtest_f("invalid-ctm-matrix-sizes")
> - invalid_ctm_matrix_sizes(&data);
> -
> - igt_fixture {
> - igt_display_fini(&data.display);
> - }
> -}
> diff --git a/tests/kms_pipe_color_basic.c b/tests/kms_pipe_color_basic.c
> new file mode 100644
> index 0000000..9f7ac7e
> --- /dev/null
> +++ b/tests/kms_pipe_color_basic.c
> @@ -0,0 +1,1184 @@
> +/*
> + * Copyright © 2015 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");
> +
> +/* Data structures for gamma/degamma ramps & ctm matrix. */
> +struct _drm_color_ctm {
> + /* Transformation matrix in S31.32 format. */
> + __s64 matrix[9];
> +};
> +
> +struct _drm_color_lut {
> + /*
> + * Data is U0.16 fixed point format.
> + */
> + __u16 red;
> + __u16 green;
> + __u16 blue;
> + __u16 reserved;
> +};
> +
> +/* Internal */
> +typedef struct {
> + double r, g, b;
> +} color_t;
> +
> +typedef struct {
> + int drm_fd;
> + uint32_t devid;
> + igt_display_t display;
> + igt_pipe_crc_t *pipe_crc;
> +
> + uint32_t color_depth;
> + uint64_t degamma_lut_size;
> + uint64_t gamma_lut_size;
> +} data_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;
> +
> + /* 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);
> + }
> +
> + cairo_destroy(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;
> +
> + /* 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);
> + }
> +
> + cairo_destroy(cr);
> +}
> +
> +static double *generate_table(uint32_t lut_size, double exp)
> +{
> + double *coeffs = malloc(sizeof(double) * lut_size);
> + uint32_t i;
> +
> + for (i = 0; i < lut_size; i++)
> + coeffs[i] = powf((double) i * 1.0 / (double) (lut_size - 1), exp);
> +
> + return coeffs;
> +}
> +
> +static double *generate_table_max(uint32_t lut_size)
> +{
> + double *coeffs = malloc(sizeof(double) * lut_size);
> + uint32_t i;
> +
> + coeffs[0] = 0.0;
> + for (i = 1; i < lut_size; i++)
> + coeffs[i] = 1.0;
> +
> + return coeffs;
> +}
> +
> +static double *generate_table_zero(uint32_t lut_size)
> +{
> + double *coeffs = malloc(sizeof(double) * lut_size);
> + uint32_t i;
> +
> + for (i = 0; i < lut_size; i++)
> + coeffs[i] = 0.0;
> +
> + return coeffs;
> +}
> +
> +static struct _drm_color_lut *coeffs_to_lut(data_t *data,
> + const double *coefficients,
> + uint32_t lut_size,
> + uint32_t color_depth,
> + int off)
> +{
> + struct _drm_color_lut *lut;
> + uint32_t i;
> + uint32_t max_value = (1 << 16) - 1;
> + uint32_t mask = ((1 << color_depth) - 1) << 8;
> +
> + 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 = (coefficients[i] * max_value);
> +
> + /*
> + * Hardware might encode colors on a different number of bits
> + * than what is in our framebuffer (10 or 12bits for example).
> + * Mask the lower bits not provided by the framebuffer so we
> + * can do CRC comparisons.
> + */
> + 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 double *coefficients)
> +{
> + size_t size = sizeof(struct _drm_color_lut) * data->degamma_lut_size;
> + struct _drm_color_lut *lut = coeffs_to_lut(data,
> + coefficients,
> + data->degamma_lut_size,
> + data->color_depth, 0);
> +
> + igt_pipe_set_degamma_lut(pipe, lut, size);
> +
> + free(lut);
> +}
> +
> +static void set_gamma(data_t *data,
> + igt_pipe_t *pipe,
> + const double *coefficients)
> +{
> + size_t size = sizeof(struct _drm_color_lut) * data->gamma_lut_size;
> + struct _drm_color_lut *lut = coeffs_to_lut(data,
> + coefficients,
> + data->gamma_lut_size,
> + data->color_depth, 0);
> +
> + igt_pipe_set_gamma_lut(pipe, 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_set_ctm_matrix(pipe, &ctm, sizeof(ctm));
> +}
> +
> +#define disable_degamma(pipe) igt_pipe_set_degamma_lut(pipe, NULL, 0)
> +#define disable_gamma(pipe) igt_pipe_set_gamma_lut(pipe, NULL, 0)
> +#define disable_ctm(pipe) igt_pipe_set_ctm_matrix(pipe, NULL, 0)
> +
> +static void output_set_property_enum(igt_output_t *output,
> + const char *property,
> + const char *enum_value)
> +{
> + int i;
> + int32_t value = -1;
> + uint32_t prop_id;
> + drmModePropertyPtr prop;
> +
> + if (!kmstest_get_property(output->display->drm_fd,
> + output->id,
> + DRM_MODE_OBJECT_CONNECTOR,
> + property,
> + &prop_id, NULL, &prop))
> + return;
> +
> + igt_assert(prop->flags & DRM_MODE_PROP_ENUM);
> +
> + for (i = 0; i < prop->count_enums; i++) {
> + if (!strcmp(prop->enums[i].name, enum_value)) {
> + value = prop->enums[i].value;
> + break;
> + }
> + }
> + igt_assert_neq(value, -1);
> +
> + igt_assert_eq(drmModeObjectSetProperty(output->display->drm_fd,
> + output->id,
> + DRM_MODE_OBJECT_CONNECTOR,
> + prop_id, value), 0);
> +
> +
> + drmModeFreeProperty(prop);
> +}
> +
> +/*
> + * Draw 3 gradient rectangles in red, green and blue, with a maxed out
> + * degamma LUT and verify we have the same CRC 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;
> + double *degamma_linear, *degamma_full;
> + double *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 }
> + };
> +
> + 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_connected_output(&data->display, output) {
> + drmModeModeInfo *mode;
> + struct igt_fb fb_modeset, fb;
> + igt_crc_t crc_fullgamma, crc_fullcolors;
> + int fb_id, fb_modeset_id;
> +
> + 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);
> + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors);
> +
> + /* 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);
> + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma);
> +
> + /* Verify that the CRC of the software computed output is
> + * equal to the CRC of the degamma LUT transformation output.
> + */
> + igt_assert_crc_equal(&crc_fullgamma, &crc_fullcolors);
> +
> + igt_output_set_pipe(output, PIPE_ANY);
> + }
> +
> + free(degamma_linear);
> + free(degamma_full);
> + free(gamma_linear);
> +}
> +
> +/*
> + * Draw 3 gradient rectangles in red, green and blue, with a maxed out gamma
> + * LUT and verify we have the same CRC as drawing solid color rectangles.
> + */
> +static void test_pipe_gamma(data_t *data,
> + igt_plane_t *primary)
> +{
> + igt_output_t *output;
> + double *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 }
> + };
> +
> + gamma_full = generate_table_max(data->gamma_lut_size);
> +
> + for_each_connected_output(&data->display, output) {
> + drmModeModeInfo *mode;
> + struct igt_fb fb_modeset, fb;
> + igt_crc_t crc_fullgamma, crc_fullcolors;
> + int fb_id, fb_modeset_id;
> +
> + 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);
> + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors);
> +
> + /* 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);
> + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma);
> +
> + /* Verify that the CRC of the software computed output is
> + * equal to the CRC of the gamma LUT transformation output.
> + */
> + igt_assert_crc_equal(&crc_fullgamma, &crc_fullcolors);
> +
> + igt_output_set_pipe(output, PIPE_ANY);
> + }
> +
> + free(gamma_full);
> +}
> +
> +/*
> + * Draw 3 gradient rectangles in red, green and blue, with a maxed out legacy
> + * gamma LUT and verify we have the same CRC as drawing solid color rectangles
> + * with linear legacy gamma LUT.
> + */
> +static void test_pipe_legacy_gamma(data_t *data,
> + igt_plane_t *primary)
> +{
> + igt_output_t *output;
> + color_t red_green_blue[] = {
> + { 1.0, 0.0, 0.0 },
> + { 0.0, 1.0, 0.0 },
> + { 0.0, 0.0, 1.0 }
> + };
> + drmModeCrtc *kms_crtc;
> + uint32_t i, legacy_lut_size;
> + uint16_t *red_lut, *green_lut, *blue_lut;
> +
> + kms_crtc = drmModeGetCrtc(data->drm_fd, primary->pipe->crtc_id);
> + legacy_lut_size = kms_crtc->gamma_size;
> + drmModeFreeCrtc(kms_crtc);
> +
> + red_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
> + green_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
> + blue_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
> +
> + for_each_connected_output(&data->display, output) {
> + drmModeModeInfo *mode;
> + struct igt_fb fb_modeset, fb;
> + igt_crc_t crc_fullgamma, crc_fullcolors;
> + int fb_id, fb_modeset_id;
> +
> + 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_degamma(primary->pipe);
> + disable_gamma(primary->pipe);
> + disable_ctm(primary->pipe);
> + 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);
> + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors);
> +
> + /* 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);
> +
> + red_lut[0] = green_lut[0] = blue_lut[0] = 0;
> + for (i = 1; i < legacy_lut_size; i++)
> + red_lut[i] = green_lut[i] = blue_lut[i] = 0xffff;
> + igt_assert_eq(drmModeCrtcSetGamma(data->drm_fd, primary->pipe->crtc_id,
> + legacy_lut_size, red_lut, green_lut, blue_lut), 0);
> + igt_display_commit(&data->display);
> + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma);
> +
> + /* Verify that the CRC of the software computed output is
> + * equal to the CRC of the gamma LUT transformation output.
> + */
> + igt_assert_crc_equal(&crc_fullgamma, &crc_fullcolors);
> +
> + /* Reset output. */
> + for (i = 1; i < legacy_lut_size; i++)
> + red_lut[i] = green_lut[i] = blue_lut[i] = i << 8;
> +
> + igt_assert_eq(drmModeCrtcSetGamma(data->drm_fd, primary->pipe->crtc_id,
> + legacy_lut_size, red_lut, green_lut, blue_lut), 0);
> + igt_display_commit(&data->display);
> +
> + igt_output_set_pipe(output, PIPE_ANY);
> + }
> +
> + free(red_lut);
> + free(green_lut);
> + free(blue_lut);
> +}
> +
> +static drmModePropertyBlobPtr
> +get_blob(data_t *data, igt_pipe_t *pipe, const char *property_name)
> +{
> + uint64_t prop_value;
> + drmModePropertyPtr prop;
> + drmModePropertyBlobPtr blob;
> +
> + igt_assert(igt_pipe_get_property(pipe, property_name,
> + NULL, &prop_value, &prop));
> +
> + if (prop_value == 0)
> + return NULL;
> +
> + igt_assert(prop->flags & DRM_MODE_PROP_BLOB);
> + blob = drmModeGetPropertyBlob(data->drm_fd, prop_value);
> + drmModeFreeProperty(prop);
> +
> + return blob;
> +}
> +
> +/*
> + * Verify that setting the legacy gamma LUT resets the gamma LUT set
> + * through the GAMMA_LUT property.
> + */
> +static void test_pipe_legacy_gamma_reset(data_t *data,
> + igt_plane_t *primary)
> +{
> + const double ctm_identity[] = {
> + 1.0, 0.0, 0.0,
> + 0.0, 1.0, 0.0,
> + 0.0, 0.0, 1.0
> + };
> + drmModeCrtc *kms_crtc;
> + double *degamma_linear, *gamma_zero;
> + uint32_t i, legacy_lut_size;
> + uint16_t *red_lut, *green_lut, *blue_lut;
> + struct _drm_color_lut *lut;
> + drmModePropertyBlobPtr blob;
> + igt_output_t *output;
> +
> + degamma_linear = generate_table(data->degamma_lut_size, 1.0);
> + gamma_zero = generate_table_zero(data->gamma_lut_size);
> +
> + for_each_connected_output(&data->display, output) {
> + igt_output_set_pipe(output, primary->pipe->pipe);
> +
> + /* Ensure we have a clean state to start with. */
> + disable_degamma(primary->pipe);
> + disable_ctm(primary->pipe);
> + disable_gamma(primary->pipe);
> + igt_display_commit(&data->display);
> +
> + /* Set a degama & gamma LUT and a CTM using the
> + * properties and verify the content of the
> + * properties. */
> + set_degamma(data, primary->pipe, degamma_linear);
> + set_ctm(primary->pipe, ctm_identity);
> + set_gamma(data, primary->pipe, gamma_zero);
> + igt_display_commit(&data->display);
> +
> + blob = get_blob(data, primary->pipe, "DEGAMMA_LUT");
> + igt_assert(blob &&
> + blob->length == (sizeof(struct _drm_color_lut) *
> + data->degamma_lut_size));
> + drmModeFreePropertyBlob(blob);
> +
> + blob = get_blob(data, primary->pipe, "CTM");
> + igt_assert(blob &&
> + blob->length == sizeof(struct _drm_color_ctm));
> + drmModeFreePropertyBlob(blob);
> +
> + blob = get_blob(data, primary->pipe, "GAMMA_LUT");
> + igt_assert(blob &&
> + blob->length == (sizeof(struct _drm_color_lut) *
> + data->gamma_lut_size));
> + lut = (struct _drm_color_lut *) blob->data;
> + for (i = 0; i < data->gamma_lut_size; i++)
> + igt_assert(lut[i].red == 0 &&
> + lut[i].green == 0 &&
> + lut[i].blue == 0);
> + drmModeFreePropertyBlob(blob);
> +
> + /* Set a gamma LUT using the legacy ioctl and verify
> + * the content of the GAMMA_LUT property is changed
> + * and that CTM and DEGAMMA_LUT are empty. */
> + kms_crtc = drmModeGetCrtc(data->drm_fd, primary->pipe->crtc_id);
> + legacy_lut_size = kms_crtc->gamma_size;
> + drmModeFreeCrtc(kms_crtc);
> +
> + red_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
> + green_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
> + blue_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
> +
> + for (i = 0; i < legacy_lut_size; i++)
> + red_lut[i] = green_lut[i] = blue_lut[i] = 0xffff;
> +
> + igt_assert_eq(drmModeCrtcSetGamma(data->drm_fd,
> + primary->pipe->crtc_id,
> + legacy_lut_size,
> + red_lut, green_lut, blue_lut),
> + 0);
> + igt_display_commit(&data->display);
> +
> + igt_assert(get_blob(data, primary->pipe,
> + "DEGAMMA_LUT") == NULL);
> + igt_assert(get_blob(data, primary->pipe, "CTM") == NULL);
> +
> + blob = get_blob(data, primary->pipe, "GAMMA_LUT");
> + igt_assert(blob &&
> + blob->length == (sizeof(struct _drm_color_lut) *
> + legacy_lut_size));
> + lut = (struct _drm_color_lut *) blob->data;
> + for (i = 0; i < legacy_lut_size; i++)
> + igt_assert(lut[i].red == 0xffff &&
> + lut[i].green == 0xffff &&
> + lut[i].blue == 0xffff);
> + drmModeFreePropertyBlob(blob);
> +
> + igt_output_set_pipe(output, PIPE_ANY);
> + }
> +
> + free(degamma_linear);
> + free(gamma_zero);
> +}
> +
> +/*
> + * Draw 3 rectangles using before colors with the ctm matrix apply and verify
> + * the CRC 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
> + };
> + double *degamma_linear, *gamma_linear;
> + igt_output_t *output;
> + bool ret = true;
> +
> + degamma_linear = generate_table(data->degamma_lut_size, 1.0);
> + gamma_linear = generate_table(data->gamma_lut_size, 1.0);
> +
> + for_each_connected_output(&data->display, output) {
> + drmModeModeInfo *mode;
> + struct igt_fb fb_modeset, fb;
> + igt_crc_t crc_software, crc_hardware;
> + int fb_id, fb_modeset_id;
> +
> + 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);
> + 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);
> + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_software);
> +
> + /* 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);
> + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_hardware);
> +
> + /* Verify that the CRC of the software computed output is
> + * equal to the CRC of the CTM matrix transformation output.
> + */
> + ret &= igt_crc_equal(&crc_software, &crc_hardware);
> +
> + igt_output_set_pipe(output, PIPE_ANY);
> + }
> +
> + free(degamma_linear);
> + free(gamma_linear);
> +
> + return ret;
> +}
> +
> +/*
> + * Hardware computes CRC based on the number of bits it is working with (8,
> + * 10, 12, 16 bits), meaning with a framebuffer of 8bits per color will
> + * usually leave the remaining lower bits at 0.
> + *
> + * We're programming the gamma LUT in order to get rid of those lower bits so
> + * we can compare the CRC of a framebuffer without any transformation to a CRC
> + * with transformation applied and verify the CRCs match.
> + *
> + * This test is currently disabled as the CRC computed on Intel hardware seems
> + * to include data on the lower bits, this is preventing us to CRC checks.
> + */
> +#if 0
> +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 };
> + double *degamma_linear, *gamma_linear;
> + igt_output_t *output;
> +
> + degamma_linear = generate_table(data->degamma_lut_size, 1.0);
> + gamma_linear = generate_table(data->gamma_lut_size, 1.0);
> +
> + for_each_connected_output(&data->display, output) {
> + drmModeModeInfo *mode;
> + struct igt_fb fb_modeset, fb;
> + igt_crc_t crc_full, crc_limited;
> + int fb_id, fb_modeset_id;
> +
> + 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);
> +
> + output_set_property_enum(output, "Broadcast RGB", "Full");
> + paint_rectangles(data, mode, red_green_blue_limited, &fb);
> + igt_plane_set_fb(primary, &fb);
> + igt_display_commit(&data->display);
> + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_full);
> +
> + /* Set the output into limited range. */
> + output_set_property_enum(output, "Broadcast RGB", "Limited 16:235");
> + paint_rectangles(data, mode, red_green_blue_full, &fb);
> + igt_plane_set_fb(primary, &fb);
> + igt_display_commit(&data->display);
> + igt_wait_for_vblank(data->drm_fd, primary->pipe->pipe);
> + igt_pipe_crc_collect_crc(data->pipe_crc, &crc_limited);
> +
> + /* Verify that the CRC of the software computed output is
> + * equal to the CRC of the CTM matrix transformation output.
> + */
> + igt_assert_crc_equal(&crc_full, &crc_limited);
> +
> + igt_output_set_pipe(output, PIPE_ANY);
> + }
> +
> + free(gamma_linear);
> + free(degamma_linear);
> +}
> +#endif
> +
> +static void
> +run_tests_for_pipe(data_t *data, enum pipe p)
> +{
> + igt_output_t *output;
> + 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_pipe_crc();
> +
> + if (p >= data->display.n_pipes)
> + return;
> +
> + pipe = &data->display.pipes[p];
> + if (pipe->n_planes < IGT_PLANE_PRIMARY)
> + return;
> +
> + primary = &pipe->planes[IGT_PLANE_PRIMARY];
> +
> + data->pipe_crc = igt_pipe_crc_new(primary->pipe->pipe,
> + INTEL_PIPE_CRC_SOURCE_AUTO);
> +
> + igt_require(igt_pipe_get_property(&data->display.pipes[p],
> + "DEGAMMA_LUT_SIZE",
> + NULL,
> + &data->degamma_lut_size,
> + NULL));
> + igt_require(igt_pipe_get_property(&data->display.pipes[p],
> + "GAMMA_LUT_SIZE",
> + NULL,
> + &data->gamma_lut_size,
> + NULL));
> +
> + for_each_connected_output(&data->display, output)
> + output_set_property_enum(output, "Broadcast RGB", "Full");
> + }
> +
> + /* We assume an 8bits depth per color for degamma/gamma LUTs
> + * for CRC checks with framebuffer references. */
> + data->color_depth = 8;
> + delta = 1.0 / (1 << data->color_depth);
> +
> + igt_subtest_f("ctm-red-to-blue-pipe%d", 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_subtest_f("ctm-green-to-red-pipe%d", 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_subtest_f("ctm-blue-to-red-pipe%d", 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_subtest_f("ctm-0-25-pipe%d", 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_subtest_f("ctm-0-5-pipe%d", 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_subtest_f("ctm-0-75-pipe%d", 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_subtest_f("ctm-max-pipe%d", 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_subtest_f("ctm-negative-pipe%d", 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));
> + }
> +
> +#if 0
> + igt_subtest_f("ctm-limited-range-pipe%d", p)
> + test_pipe_limited_range_ctm(data, primary);
> +#endif
> +
> + igt_subtest_f("degamma-pipe%d", p)
> + test_pipe_degamma(data, primary);
> +
> + igt_subtest_f("gamma-pipe%d", p)
> + test_pipe_gamma(data, primary);
> +
> + igt_subtest_f("legacy-gamma-pipe%d", p)
> + test_pipe_legacy_gamma(data, primary);
> +
> + igt_subtest_f("legacy-gamma-reset-pipe%d", p)
> + test_pipe_legacy_gamma_reset(data, primary);
> +
> + igt_fixture {
> + for_each_connected_output(&data->display, output)
> + output_set_property_enum(output, "Broadcast RGB", "Full");
> +
> + disable_degamma(primary->pipe);
> + disable_gamma(primary->pipe);
> + disable_ctm(primary->pipe);
> + igt_display_commit(&data->display);
> +
> + igt_pipe_crc_free(data->pipe_crc);
> + data->pipe_crc = NULL;
> + }
> +}
> +
> +static int
> +pipe_set_property_blob_id(igt_pipe_t *pipe, const char *property, uint32_t blob_id)
> +{
> + uint32_t prop_id;
> +
> + igt_assert(kmstest_get_property(pipe->display->drm_fd,
> + pipe->crtc_id,
> + DRM_MODE_OBJECT_CRTC,
> + property,
> + &prop_id, NULL, NULL));
> +
> + return drmModeObjectSetProperty(pipe->display->drm_fd,
> + pipe->crtc_id,
> + DRM_MODE_OBJECT_CRTC,
> + prop_id, blob_id);
> +}
> +
> +static int
> +pipe_set_property_blob(igt_pipe_t *pipe, const char *property, void *ptr, size_t length)
> +{
> + int ret = 0;
> + uint32_t blob_id = 0;
> +
> + if (length > 0)
> + igt_assert_eq(drmModeCreatePropertyBlob(pipe->display->drm_fd,
> + ptr, length,
> + &blob_id), 0);
> +
> + ret = pipe_set_property_blob_id(pipe, property, blob_id);
> +
> + if (blob_id != 0)
> + igt_assert_eq(drmModeDestroyPropertyBlob(pipe->display->drm_fd, blob_id), 0);
> +
> + return ret;
> +}
> +
> +static void
> +invalid_lut_sizes(data_t *data)
> +{
> + igt_pipe_t *pipe = &data->display.pipes[0];
> + size_t degamma_lut_size = data->degamma_lut_size * sizeof(struct _drm_color_lut);
> + size_t gamma_lut_size = data->gamma_lut_size * sizeof(struct _drm_color_lut);
> +
> + struct _drm_color_lut *degamma_lut = malloc(data->degamma_lut_size * sizeof(struct _drm_color_lut) * 2);
> + struct _drm_color_lut *gamma_lut = malloc(data->gamma_lut_size * sizeof(struct _drm_color_lut) * 2);
> +
> + igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT",
> + degamma_lut, 1), -EINVAL);
> + igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT",
> + degamma_lut, degamma_lut_size + 1),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT",
> + degamma_lut, degamma_lut_size - 1),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob(pipe, "DEGAMMA_LUT",
> + degamma_lut, degamma_lut_size + sizeof(struct _drm_color_lut)),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob_id(pipe, "DEGAMMA_LUT", pipe->crtc_id),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob_id(pipe, "DEGAMMA_LUT", 4096 * 4096),
> + -EINVAL);
> +
> + igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT",
> + gamma_lut, 1),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT",
> + gamma_lut, gamma_lut_size + 1),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT",
> + gamma_lut, gamma_lut_size - 1),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob(pipe, "GAMMA_LUT",
> + gamma_lut, gamma_lut_size + sizeof(struct _drm_color_lut)),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob_id(pipe, "GAMMA_LUT", pipe->crtc_id),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob_id(pipe, "GAMMA_LUT", 4096 * 4096),
> + -EINVAL);
> +
> + free(degamma_lut);
> + free(gamma_lut);
> +}
> +
> +static void
> +invalid_ctm_matrix_sizes(data_t *data)
> +{
> + igt_pipe_t *pipe = &data->display.pipes[0];
> + void *ptr = malloc(sizeof(struct _drm_color_ctm) * 4);
> +
> + igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr, 1),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr,
> + sizeof(struct _drm_color_ctm) + 1),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr,
> + sizeof(struct _drm_color_ctm) - 1),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob(pipe, "CTM", ptr,
> + sizeof(struct _drm_color_ctm) * 2),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob_id(pipe, "CTM", pipe->crtc_id),
> + -EINVAL);
> + igt_assert_eq(pipe_set_property_blob_id(pipe, "CTM", 4096 * 4096),
> + -EINVAL);
> +
> + free(ptr);
> +}
> +
> +igt_main
> +{
> + data_t data = {};
> +
> + igt_skip_on_simulation();
> +
> + igt_fixture {
> + data.drm_fd = drm_open_driver_master(DRIVER_INTEL);
> + data.devid = intel_get_drm_devid(data.drm_fd);
> + kmstest_set_vt_graphics_mode();
> +
> + igt_display_init(&data.display, data.drm_fd);
> + }
> +
> + for (int pipe = 0; pipe < I915_MAX_PIPES; pipe++)
> + run_tests_for_pipe(&data, pipe);
> +
> + igt_subtest_f("invalid-lut-sizes")
> + invalid_lut_sizes(&data);
> +
> + igt_subtest_f("invalid-ctm-matrix-sizes")
> + invalid_ctm_matrix_sizes(&data);
> +
> + igt_fixture {
> + igt_display_fini(&data.display);
> + }
> +}
> --
> 2.8.1
>
> _______________________________________________
> Intel-gfx mailing list
> Intel-gfx@xxxxxxxxxxxxxxxxxxxxx
> https://lists.freedesktop.org/mailman/listinfo/intel-gfx
--
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
Intel-gfx@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
