From patchwork Wed Jul 12 14:50:26 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paul Kocialkowki X-Patchwork-Id: 9836911 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id BBCF660363 for ; Wed, 12 Jul 2017 14:51:12 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id AE501285DB for ; Wed, 12 Jul 2017 14:51:12 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id A31C4285ED; Wed, 12 Jul 2017 14:51:12 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-4.2 required=2.0 tests=BAYES_00, RCVD_IN_DNSWL_MED autolearn=ham version=3.3.1 Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 0F4AE285DD for ; Wed, 12 Jul 2017 14:51:12 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 3B8626E425; Wed, 12 Jul 2017 14:51:11 +0000 (UTC) X-Original-To: intel-gfx@lists.freedesktop.org Delivered-To: intel-gfx@lists.freedesktop.org Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by gabe.freedesktop.org (Postfix) with ESMTPS id A01986E424 for ; Wed, 12 Jul 2017 14:51:09 +0000 (UTC) Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by fmsmga101.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 12 Jul 2017 07:51:09 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.40,350,1496127600"; d="scan'208";a="286011411" Received: from linux.intel.com ([10.54.29.200]) by fmsmga004.fm.intel.com with ESMTP; 12 Jul 2017 07:51:08 -0700 Received: from workstation.fi.intel.com (workstation.fi.intel.com [10.237.68.144]) by linux.intel.com (Postfix) with ESMTP id BEB675804B7; Wed, 12 Jul 2017 07:51:06 -0700 (PDT) From: Paul Kocialkowski To: intel-gfx@lists.freedesktop.org Date: Wed, 12 Jul 2017 17:50:26 +0300 Message-Id: <20170712145031.3531-3-paul.kocialkowski@linux.intel.com> X-Mailer: git-send-email 2.13.2 In-Reply-To: <20170712145031.3531-1-paul.kocialkowski@linux.intel.com> References: <20170705080435.26789-1-paul.kocialkowski@linux.intel.com> <20170712145031.3531-1-paul.kocialkowski@linux.intel.com> Cc: Lyude Subject: [Intel-gfx] [PATCH i-g-t v4 2/7] chamelium: Calculate CRC from framebuffer instead of hardcoding it X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" X-Virus-Scanned: ClamAV using ClamSMTP This introduces CRC calculation for reference frames, instead of using hardcoded values for them. The rendering of reference frames may differ from machine to machine, especially due to font rendering, and the frame itself may change with subsequent IGT changes. These differences would cause the CRC checks to fail on different setups. This allows them to pass regardless of the setup. Signed-off-by: Paul Kocialkowski --- lib/igt_chamelium.c | 143 ++++++++++++++++++++++++++++++++++++++++++++++++++++ lib/igt_chamelium.h | 5 ++ tests/chamelium.c | 77 +++++++--------------------- 3 files changed, 167 insertions(+), 58 deletions(-) diff --git a/lib/igt_chamelium.c b/lib/igt_chamelium.c index 93392af7..baa6399c 100644 --- a/lib/igt_chamelium.c +++ b/lib/igt_chamelium.c @@ -94,6 +94,14 @@ struct chamelium_frame_dump { struct chamelium_port *port; }; +struct chamelium_fb_crc_async_data { + int fd; + struct igt_fb *fb; + + pthread_t thread_id; + igt_crc_t *ret; +}; + struct chamelium { xmlrpc_env env; xmlrpc_client *client; @@ -998,6 +1006,141 @@ int chamelium_get_frame_limit(struct chamelium *chamelium, return ret; } +static uint32_t chamelium_xrgb_hash16(const unsigned char *buffer, int width, + int height, int k, int m) +{ + unsigned char r, g, b; + uint64_t sum = 0; + uint64_t count = 0; + uint64_t value; + uint32_t hash; + int index; + int i; + + for (i=0; i < width * height; i++) { + if ((i % m) != k) + continue; + + index = i * 4; + + r = buffer[index + 2]; + g = buffer[index + 1]; + b = buffer[index + 0]; + + value = r | (g << 8) | (b << 16); + sum += ++count * value; + } + + hash = ((sum >> 0) ^ (sum >> 16) ^ (sum >> 32) ^ (sum >> 48)) & 0xffff; + + return hash; +} + +static void chamelium_do_calculate_fb_crc(int fd, struct igt_fb *fb, + igt_crc_t *out) +{ + unsigned char *buffer; + cairo_surface_t *fb_surface; + int n = 4; + int w, h; + int i, j; + + /* Get the cairo surface for the framebuffer */ + fb_surface = igt_get_cairo_surface(fd, fb); + + buffer = cairo_image_surface_get_data(fb_surface); + w = fb->width; + h = fb->height; + + for (i = 0; i < n; i++) { + j = n - i - 1; + out->crc[i] = chamelium_xrgb_hash16(buffer, w, h, j, n); + } + + out->n_words = n; +} + +/** + * chamelium_calculate_fb_crc: + * @fd: The drm file descriptor + * @fb: The framebuffer to calculate the CRC for + * + * Calculates the CRC for the provided framebuffer, using the Chamelium's CRC + * algorithm. This calculates the CRC in a synchronous fashion. + * + * Returns: The calculated CRC + */ +igt_crc_t *chamelium_calculate_fb_crc(int fd, struct igt_fb *fb) +{ + igt_crc_t *ret = calloc(1, sizeof(igt_crc_t)); + + chamelium_do_calculate_fb_crc(fd, fb, ret); + + return ret; +} + +static void *chamelium_calculate_fb_crc_async_work(void *data) +{ + struct chamelium_fb_crc_async_data *fb_crc; + + fb_crc = (struct chamelium_fb_crc_async_data *) data; + + chamelium_do_calculate_fb_crc(fb_crc->fd, fb_crc->fb, fb_crc->ret); + + return NULL; +} + +/** + * chamelium_calculate_fb_crc_launch: + * @fd: The drm file descriptor + * @fb: The framebuffer to calculate the CRC for + * + * Launches the CRC calculation for the provided framebuffer, using the + * Chamelium's CRC algorithm. This calculates the CRC in an asynchronous + * fashion. + * + * The returned structure should be passed to a subsequent call to + * chamelium_calculate_fb_crc_result. It should not be freed. + * + * Returns: An intermediate structure for the CRC calculation work. + */ +struct chamelium_fb_crc_async_data *chamelium_calculate_fb_crc_async_start(int fd, + struct igt_fb *fb) +{ + struct chamelium_fb_crc_async_data *fb_crc; + + fb_crc = calloc(1, sizeof(struct chamelium_fb_crc_async_data)); + fb_crc->ret = calloc(1, sizeof(igt_crc_t)); + fb_crc->fd = fd; + fb_crc->fb = fb; + + pthread_create(&fb_crc->thread_id, NULL, + chamelium_calculate_fb_crc_async_work, fb_crc); + + return fb_crc; +} + +/** + * chamelium_calculate_fb_crc_result: + * @fb_crc: An intermediate structure with thread-related information + * + * Blocks until the asynchronous CRC calculation is finished, and then returns + * its result. + * + * Returns: The calculated CRC + */ +igt_crc_t *chamelium_calculate_fb_crc_async_finish(struct chamelium_fb_crc_async_data *fb_crc) +{ + igt_crc_t *ret; + + pthread_join(fb_crc->thread_id, NULL); + + ret = fb_crc->ret; + free(fb_crc); + + return ret; +} + static unsigned int chamelium_get_port_type(struct chamelium *chamelium, struct chamelium_port *port) { diff --git a/lib/igt_chamelium.h b/lib/igt_chamelium.h index 81322ad2..2bfbfdc7 100644 --- a/lib/igt_chamelium.h +++ b/lib/igt_chamelium.h @@ -36,6 +36,7 @@ struct chamelium; struct chamelium_port; struct chamelium_frame_dump; +struct chamelium_fb_crc_async_data; struct chamelium *chamelium_init(int drm_fd); void chamelium_deinit(struct chamelium *chamelium); @@ -92,6 +93,10 @@ struct chamelium_frame_dump *chamelium_port_dump_pixels(struct chamelium *chamel struct chamelium_port *port, int x, int y, int w, int h); +igt_crc_t *chamelium_calculate_fb_crc(int fd, struct igt_fb *fb); +struct chamelium_fb_crc_async_data *chamelium_calculate_fb_crc_async_start(int fd, + struct igt_fb *fb); +igt_crc_t *chamelium_calculate_fb_crc_async_finish(struct chamelium_fb_crc_async_data *fb_crc); int chamelium_get_captured_frame_count(struct chamelium *chamelium); int chamelium_get_frame_limit(struct chamelium *chamelium, struct chamelium_port *port, diff --git a/tests/chamelium.c b/tests/chamelium.c index e26f0557..da98de47 100644 --- a/tests/chamelium.c +++ b/tests/chamelium.c @@ -49,43 +49,6 @@ typedef struct { #define HPD_TOGGLE_COUNT_VGA 5 #define HPD_TOGGLE_COUNT_DP_HDMI 15 -/* Pre-calculated CRCs for the pattern fb, for all the modes in the default - * chamelium edid - */ -struct crc_entry { - int width; - int height; - igt_crc_t crc; -}; - -#define CRC_ENTRY(w_, h_, ...) \ - { w_, h_, { .n_words = 4, .crc = { __VA_ARGS__ } } } - -static const struct crc_entry pattern_fb_crcs[] = { - CRC_ENTRY(1920, 1080, 0xf859, 0xa751, 0x8c81, 0x45a1), - CRC_ENTRY(1280, 720, 0xcec2, 0x4246, 0x6cfd, 0xeb43), - CRC_ENTRY(1024, 768, 0x85e5, 0xf0cd, 0xafe3, 0x7f18), - CRC_ENTRY( 800, 600, 0x6b39, 0x32b6, 0x831a, 0xb03e), - CRC_ENTRY( 640, 480, 0xa121, 0x2473, 0xb150, 0x8c47), -}; -#undef CRC_ENTRY - -static const igt_crc_t * -get_precalculated_crc(struct chamelium_port *port, int w, int h) -{ - int i; - const struct crc_entry *entry; - - for (i = 0; i < ARRAY_SIZE(pattern_fb_crcs); i++) { - entry = &pattern_fb_crcs[i]; - - if (entry->width == w && entry->height == h) - return &entry->crc; - } - - return NULL; -} - static void require_connector_present(data_t *data, unsigned int type) { @@ -422,7 +385,8 @@ test_display_crc_single(data_t *data, struct chamelium_port *port) igt_output_t *output; igt_plane_t *primary; igt_crc_t *crc; - const igt_crc_t *expected_crc; + igt_crc_t *expected_crc; + struct chamelium_fb_crc_async_data *fb_crc; struct igt_fb fb; drmModeModeInfo *mode; drmModeConnector *connector; @@ -445,24 +409,21 @@ test_display_crc_single(data_t *data, struct chamelium_port *port) 0, 0, 0, &fb); igt_assert(fb_id > 0); + fb_crc = chamelium_calculate_fb_crc_async_start(data->drm_fd, + &fb); enable_output(data, port, output, mode, &fb); - expected_crc = get_precalculated_crc(port, - mode->hdisplay, - mode->vdisplay); - if (!expected_crc) { - igt_warn("No precalculated CRC found for %dx%d, skipping CRC check\n", - mode->hdisplay, mode->vdisplay); - goto next; - } - igt_debug("Testing single CRC fetch\n"); + crc = chamelium_get_crc_for_area(data->chamelium, port, 0, 0, 0, 0); + + expected_crc = chamelium_calculate_fb_crc_async_finish(fb_crc); + igt_assert_crc_equal(crc, expected_crc); + free(expected_crc); free(crc); -next: disable_output(data, port, output); igt_remove_fb(data->drm_fd, &fb); } @@ -478,7 +439,8 @@ test_display_crc_multiple(data_t *data, struct chamelium_port *port) igt_output_t *output; igt_plane_t *primary; igt_crc_t *crc; - const igt_crc_t *expected_crc; + igt_crc_t *expected_crc; + struct chamelium_fb_crc_async_data *fb_crc; struct igt_fb fb; drmModeModeInfo *mode; drmModeConnector *connector; @@ -501,15 +463,10 @@ test_display_crc_multiple(data_t *data, struct chamelium_port *port) 0, 0, 0, &fb); igt_assert(fb_id > 0); - enable_output(data, port, output, mode, &fb); + fb_crc = chamelium_calculate_fb_crc_async_start(data->drm_fd, + &fb); - expected_crc = get_precalculated_crc(port, mode->hdisplay, - mode->vdisplay); - if (!expected_crc) { - igt_warn("No precalculated CRC found for %dx%d, skipping CRC check\n", - mode->hdisplay, mode->vdisplay); - goto next; - } + enable_output(data, port, output, mode, &fb); /* We want to keep the display running for a little bit, since * there's always the potential the driver isn't able to keep @@ -520,11 +477,15 @@ test_display_crc_multiple(data_t *data, struct chamelium_port *port) &captured_frame_count); igt_debug("Captured %d frames\n", captured_frame_count); + + expected_crc = chamelium_calculate_fb_crc_async_finish(fb_crc); + for (j = 0; j < captured_frame_count; j++) igt_assert_crc_equal(&crc[j], expected_crc); + + free(expected_crc); free(crc); -next: disable_output(data, port, output); igt_remove_fb(data->drm_fd, &fb); }