mirror of
https://gitlab.freedesktop.org/wayland/weston.git
synced 2025-12-20 05:50:10 +01:00
811edc0a8c
Now that new formats are supported by the Vulkan renderer, update this list to match our driver in CI for a more reasonable coverage. Signed-off-by: Erico Nunes <nunes.erico@gmail.com>
1783 lines
47 KiB
C
1783 lines
47 KiB
C
/*
|
|
* Copyright © 2020 Collabora, Ltd.
|
|
*
|
|
* 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 "config.h"
|
|
|
|
#include <fcntl.h>
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <sys/mman.h>
|
|
#include <unistd.h>
|
|
|
|
#include "test-config.h"
|
|
#include "weston-test-client-helper.h"
|
|
#include "weston-test-fixture-compositor.h"
|
|
#include "image-iter.h"
|
|
#include "pixel-formats.h"
|
|
#include "shared/client-buffer-util.h"
|
|
#include "shared/os-compatibility.h"
|
|
#include "shared/weston-drm-fourcc.h"
|
|
#include "shared/xalloc.h"
|
|
|
|
/* XXX For formats with more than 8 bit pre component, we should ideally load a
|
|
* 16-bit (or 32-bit) per component image and store into a 16-bit (or 32-bit)
|
|
* per component renderbuffer so that we can ensure the additional precision is
|
|
* correctly handled. */
|
|
|
|
struct setup_args {
|
|
struct fixture_metadata meta;
|
|
enum weston_renderer_type renderer;
|
|
const char *logging_scopes;
|
|
|
|
/* Formats in these arrays can be defined per renderer and must be
|
|
* advertised and supported by the renderer.
|
|
* If undefined, all formats checked by the test are considered
|
|
* must pass. */
|
|
const uint32_t *shm_format_must_pass;
|
|
size_t shm_format_num;
|
|
const uint32_t *dmabuf_format_must_pass;
|
|
size_t dmabuf_format_num;
|
|
|
|
bool gl_force_import_yuv_fallback;
|
|
};
|
|
|
|
/* Formats supported by llvmpipe as of Mesa 25.0.4 */
|
|
static const uint32_t gl_dmabuf_format_must_pass[] = {
|
|
DRM_FORMAT_RGB565,
|
|
DRM_FORMAT_XRGB8888,
|
|
DRM_FORMAT_ARGB8888,
|
|
DRM_FORMAT_XBGR8888,
|
|
DRM_FORMAT_ABGR8888,
|
|
DRM_FORMAT_XRGB2101010,
|
|
DRM_FORMAT_ARGB2101010,
|
|
DRM_FORMAT_XBGR2101010,
|
|
DRM_FORMAT_ABGR2101010,
|
|
DRM_FORMAT_XBGR16161616,
|
|
DRM_FORMAT_ABGR16161616,
|
|
DRM_FORMAT_XBGR16161616F,
|
|
DRM_FORMAT_ABGR16161616F,
|
|
DRM_FORMAT_YUV420,
|
|
DRM_FORMAT_YVU420,
|
|
DRM_FORMAT_YUV422,
|
|
DRM_FORMAT_YVU422,
|
|
DRM_FORMAT_YUV444,
|
|
DRM_FORMAT_YVU444,
|
|
DRM_FORMAT_NV12,
|
|
DRM_FORMAT_NV21,
|
|
DRM_FORMAT_NV16,
|
|
DRM_FORMAT_YUYV,
|
|
DRM_FORMAT_YVYU,
|
|
DRM_FORMAT_UYVY,
|
|
DRM_FORMAT_VYUY,
|
|
DRM_FORMAT_XYUV8888,
|
|
DRM_FORMAT_P010,
|
|
DRM_FORMAT_P012,
|
|
DRM_FORMAT_P016,
|
|
};
|
|
|
|
static const uint32_t vulkan_shm_format_must_pass[] = {
|
|
DRM_FORMAT_BGRX4444,
|
|
DRM_FORMAT_BGRA4444,
|
|
DRM_FORMAT_XRGB1555,
|
|
DRM_FORMAT_ARGB1555,
|
|
DRM_FORMAT_RGBX5551,
|
|
DRM_FORMAT_RGBA5551,
|
|
DRM_FORMAT_BGRX5551,
|
|
DRM_FORMAT_BGRA5551,
|
|
DRM_FORMAT_RGB565,
|
|
DRM_FORMAT_BGR565,
|
|
DRM_FORMAT_XRGB8888,
|
|
DRM_FORMAT_ARGB8888,
|
|
DRM_FORMAT_XBGR8888,
|
|
DRM_FORMAT_ABGR8888,
|
|
DRM_FORMAT_XRGB2101010,
|
|
DRM_FORMAT_ARGB2101010,
|
|
DRM_FORMAT_XBGR2101010,
|
|
DRM_FORMAT_ABGR2101010,
|
|
DRM_FORMAT_XBGR16161616,
|
|
DRM_FORMAT_ABGR16161616,
|
|
DRM_FORMAT_XBGR16161616F,
|
|
DRM_FORMAT_ABGR16161616F,
|
|
};
|
|
|
|
static const uint32_t vulkan_dmabuf_format_must_pass[] = {
|
|
DRM_FORMAT_R8,
|
|
DRM_FORMAT_R16,
|
|
DRM_FORMAT_GR88,
|
|
DRM_FORMAT_GR1616,
|
|
DRM_FORMAT_BGRX4444,
|
|
DRM_FORMAT_BGRA4444,
|
|
DRM_FORMAT_XRGB1555,
|
|
DRM_FORMAT_ARGB1555,
|
|
DRM_FORMAT_RGBX5551,
|
|
DRM_FORMAT_RGBA5551,
|
|
DRM_FORMAT_BGRX5551,
|
|
DRM_FORMAT_BGRA5551,
|
|
DRM_FORMAT_RGB565,
|
|
DRM_FORMAT_BGR565,
|
|
DRM_FORMAT_XRGB8888,
|
|
DRM_FORMAT_ARGB8888,
|
|
DRM_FORMAT_XBGR8888,
|
|
DRM_FORMAT_ABGR8888,
|
|
DRM_FORMAT_XRGB2101010,
|
|
DRM_FORMAT_ARGB2101010,
|
|
DRM_FORMAT_XBGR2101010,
|
|
DRM_FORMAT_ABGR2101010,
|
|
DRM_FORMAT_XBGR16161616,
|
|
DRM_FORMAT_ABGR16161616,
|
|
DRM_FORMAT_XBGR16161616F,
|
|
DRM_FORMAT_ABGR16161616F,
|
|
};
|
|
|
|
static const struct setup_args my_setup_args[] = {
|
|
{
|
|
.meta.name = "GL",
|
|
.renderer = WESTON_RENDERER_GL,
|
|
.logging_scopes = "log,gl-shader-generator",
|
|
.dmabuf_format_must_pass = gl_dmabuf_format_must_pass,
|
|
.dmabuf_format_num = ARRAY_LENGTH(gl_dmabuf_format_must_pass),
|
|
.gl_force_import_yuv_fallback = false,
|
|
},
|
|
{
|
|
.meta.name = "GL force-import-yuv-fallback",
|
|
.renderer = WESTON_RENDERER_GL,
|
|
.logging_scopes = "log,gl-shader-generator",
|
|
.dmabuf_format_must_pass = gl_dmabuf_format_must_pass,
|
|
.dmabuf_format_num = ARRAY_LENGTH(gl_dmabuf_format_must_pass),
|
|
.gl_force_import_yuv_fallback = true,
|
|
},
|
|
{
|
|
.renderer = WESTON_RENDERER_VULKAN,
|
|
.logging_scopes = "log",
|
|
.meta.name = "Vulkan",
|
|
.shm_format_must_pass = vulkan_shm_format_must_pass,
|
|
.shm_format_num = ARRAY_LENGTH(vulkan_shm_format_must_pass),
|
|
.dmabuf_format_must_pass = vulkan_dmabuf_format_must_pass,
|
|
.dmabuf_format_num = ARRAY_LENGTH(vulkan_dmabuf_format_must_pass),
|
|
},
|
|
};
|
|
|
|
static enum test_result_code
|
|
fixture_setup(struct weston_test_harness *harness, const struct setup_args *arg)
|
|
{
|
|
struct compositor_setup setup;
|
|
|
|
compositor_setup_defaults(&setup);
|
|
setup.renderer = arg->renderer;
|
|
setup.width = 324;
|
|
setup.height = 264;
|
|
setup.shell = SHELL_TEST_DESKTOP;
|
|
setup.logging_scopes = arg->logging_scopes;
|
|
setup.refresh = HIGHEST_OUTPUT_REFRESH;
|
|
setup.test_quirks.gl_force_import_yuv_fallback =
|
|
arg->gl_force_import_yuv_fallback;
|
|
|
|
return weston_test_harness_execute_as_client(harness, &setup);
|
|
}
|
|
DECLARE_FIXTURE_SETUP_WITH_ARG(fixture_setup, my_setup_args, meta);
|
|
|
|
enum buffer_type {
|
|
BUFFER_TYPE_SHM = 1,
|
|
BUFFER_TYPE_DMABUF,
|
|
};
|
|
|
|
struct client_buffer_case {
|
|
uint32_t drm_format;
|
|
const char *drm_format_name;
|
|
int ref_seq_no;
|
|
struct client_buffer *(*create_buffer)(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image);
|
|
};
|
|
|
|
struct client_buffer_create_data {
|
|
const struct pixel_format_info *fmt;
|
|
enum buffer_type type;
|
|
int width;
|
|
int height;
|
|
};
|
|
|
|
static struct client_buffer_create_data
|
|
create_init(uint32_t drm_format, enum buffer_type type,
|
|
const struct image_header *ih)
|
|
{
|
|
return (struct client_buffer_create_data){
|
|
.fmt = pixel_format_get_info(drm_format),
|
|
.type = type,
|
|
.width = ih->width,
|
|
.height = ih->height,
|
|
};
|
|
}
|
|
|
|
static struct client_buffer *
|
|
client_buffer_create(struct client *client,
|
|
struct client_buffer_create_data *create_data)
|
|
{
|
|
struct client_buffer *buf = NULL;
|
|
|
|
switch (create_data->type) {
|
|
case BUFFER_TYPE_SHM: {
|
|
if (!support_shm_format(client,
|
|
pixel_format_get_shm_format (create_data->fmt))) {
|
|
testlog("%s: Skipped: format not supported by compositor for SHM\n",
|
|
get_test_name());
|
|
return NULL;
|
|
}
|
|
|
|
buf = client_buffer_util_create_shm_buffer(client->wl_shm,
|
|
create_data->fmt,
|
|
create_data->width,
|
|
create_data->height);
|
|
break;
|
|
}
|
|
case BUFFER_TYPE_DMABUF: {
|
|
if (!support_drm_format(client, create_data->fmt->format,
|
|
DRM_FORMAT_MOD_LINEAR)) {
|
|
testlog("%s: Skipped: format not supported by compositor for DMABUF\n",
|
|
get_test_name());
|
|
return NULL;
|
|
}
|
|
|
|
buf = client_buffer_util_create_dmabuf_buffer(client->wl_display,
|
|
client->dmabuf,
|
|
create_data->fmt,
|
|
create_data->width,
|
|
create_data->height);
|
|
break;
|
|
}
|
|
}
|
|
|
|
test_assert_ptr_not_null(buf);
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* 16 bpp RGB
|
|
*
|
|
* RGBX4444: [15:0] R:G:B:x 4:4:4:4 little endian
|
|
* RGBA4444: [15:0] R:G:B:A 4:4:4:4 little endian
|
|
*
|
|
* BGRX4444: [15:0] B:G:R:x 4:4:4:4 little endian
|
|
* BGRA4444: [15:0] B:G:R:A 4:4:4:4 little endian
|
|
*
|
|
* XRGB4444: [15:0] x:R:G:B 4:4:4:4 little endian
|
|
* ARGB4444: [15:0] A:R:G:B 4:4:4:4 little endian
|
|
*
|
|
* XBGR4444: [15:0] x:B:G:R 4:4:4:4 little endian
|
|
* ABGR4444: [15:0] A:B:G:R 4:4:4:4 little endian
|
|
*/
|
|
static struct client_buffer *
|
|
rgba4444_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
static const int swizzles[][4] = {
|
|
{ 3, 2, 1, 0 }, /* RGBX4444, RGBA4444 */
|
|
{ 1, 2, 3, 0 }, /* BGRX4444, BGRA4444 */
|
|
{ 2, 1, 0, 3 }, /* XRGB4444, ARGB4444 */
|
|
{ 0, 1, 2, 3 }, /* XBGR4444, ABGR4444 */
|
|
};
|
|
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
bool is_opaque;
|
|
int idx, x, y;
|
|
uint16_t a;
|
|
|
|
switch (drm_format) {
|
|
case DRM_FORMAT_RGBX4444:
|
|
is_opaque = true;
|
|
idx = 0;
|
|
break;
|
|
case DRM_FORMAT_RGBA4444:
|
|
is_opaque = false;
|
|
idx = 0;
|
|
break;
|
|
case DRM_FORMAT_BGRX4444:
|
|
is_opaque = true;
|
|
idx = 1;
|
|
break;
|
|
case DRM_FORMAT_BGRA4444:
|
|
is_opaque = false;
|
|
idx = 1;
|
|
break;
|
|
case DRM_FORMAT_XRGB4444:
|
|
is_opaque = true;
|
|
idx = 2;
|
|
break;
|
|
case DRM_FORMAT_ARGB4444:
|
|
is_opaque = false;
|
|
idx = 2;
|
|
break;
|
|
case DRM_FORMAT_XBGR4444:
|
|
is_opaque = true;
|
|
idx = 3;
|
|
break;
|
|
case DRM_FORMAT_ABGR4444:
|
|
is_opaque = false;
|
|
idx = 3;
|
|
break;
|
|
default:
|
|
test_assert_not_reached("Invalid format!");
|
|
};
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
/* Store alpha as 0x0 to ensure the compositor correctly replaces it
|
|
* with 0xf. */
|
|
a = is_opaque ? 0x0 : 0xf;
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
uint16_t *dst_row =
|
|
(uint16_t*) buf->data + (buf->strides[0] / sizeof(uint16_t)) * y;
|
|
uint32_t *src_row = image_header_get_row_u32(&src, y);
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
uint16_t r = (src_row[x] >> 20) & 0xf;
|
|
uint16_t g = (src_row[x] >> 12) & 0xf;
|
|
uint16_t b = (src_row[x] >> 4) & 0xf;
|
|
|
|
dst_row[x] =
|
|
r << (swizzles[idx][0] * 4) |
|
|
g << (swizzles[idx][1] * 4) |
|
|
b << (swizzles[idx][2] * 4) |
|
|
a << (swizzles[idx][3] * 4);
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* 16 bpp RGB
|
|
*
|
|
* RGBX5551: [15:0] R:G:B:x 5:5:5:1 little endian
|
|
* RGBA5551: [15:0] R:G:B:A 5:5:5:1 little endian
|
|
*
|
|
* BGRX5551: [15:0] B:G:R:x 5:5:5:1 little endian
|
|
* BGRA5551: [15:0] B:G:R:A 5:5:5:1 little endian
|
|
*/
|
|
static struct client_buffer *
|
|
rgba5551_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
|
|
int x, y;
|
|
uint16_t a;
|
|
|
|
test_assert_true(drm_format == DRM_FORMAT_RGBX5551 ||
|
|
drm_format == DRM_FORMAT_RGBA5551 ||
|
|
drm_format == DRM_FORMAT_BGRX5551 ||
|
|
drm_format == DRM_FORMAT_BGRA5551);
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
/* Store alpha as 0x0 to ensure the compositor correctly replaces it
|
|
* with 0x1. */
|
|
a = drm_format == DRM_FORMAT_RGBX5551 ||
|
|
drm_format == DRM_FORMAT_RGBX5551 ? 0x0 : 0x1;
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
uint16_t *dst_row =
|
|
(uint16_t*) buf->data + (buf->strides[0] / sizeof(uint16_t)) * y;
|
|
uint32_t *src_row = image_header_get_row_u32(&src, y);
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
uint16_t r = (src_row[x] >> 19) & 0x1f;
|
|
uint16_t g = (src_row[x] >> 11) & 0x1f;
|
|
uint16_t b = (src_row[x] >> 3) & 0x1f;
|
|
|
|
if (drm_format == DRM_FORMAT_RGBX5551 ||
|
|
drm_format == DRM_FORMAT_RGBA5551)
|
|
dst_row[x] = r << 11 | g << 6 | b << 1 | a;
|
|
else
|
|
dst_row[x] = b << 11 | g << 6 | r << 1 | a;
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* 16 bpp RGB
|
|
*
|
|
* RGB565: [15:0] R:G:B 5:6:5 little endian
|
|
* BGR565: [15:0] B:G:R 5:6:5 little endian
|
|
*/
|
|
static struct client_buffer *
|
|
rgb565_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
int x, y;
|
|
|
|
test_assert_true(drm_format == DRM_FORMAT_RGB565 ||
|
|
drm_format == DRM_FORMAT_BGR565);
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
uint16_t *dst_row =
|
|
(uint16_t*) buf->data + (buf->strides[0] / sizeof(uint16_t)) * y;
|
|
uint32_t *src_row = image_header_get_row_u32(&src, y);
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
uint16_t r = (src_row[x] >> 19) & 0x1f;
|
|
uint16_t g = (src_row[x] >> 10) & 0x3f;
|
|
uint16_t b = (src_row[x] >> 3) & 0x1f;
|
|
|
|
if (drm_format == DRM_FORMAT_RGB565)
|
|
dst_row[x] = r << 11 | g << 5 | b;
|
|
else
|
|
dst_row[x] = b << 11 | g << 5 | r;
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* 24 bpp RGB
|
|
*
|
|
* RGB888: [23:0] R:G:B 8:8:8 little endian
|
|
* BGR888: [23:0] B:G:R 8:8:8 little endian
|
|
*/
|
|
static struct client_buffer *
|
|
rgb888_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
int x, y;
|
|
|
|
test_assert_true(drm_format == DRM_FORMAT_RGB888 ||
|
|
drm_format == DRM_FORMAT_BGR888);
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
uint8_t *dst_row = (uint8_t*) buf->data + src.width * 3 * y;
|
|
uint32_t *src_row = image_header_get_row_u32(&src, y);
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
uint8_t r = src_row[x] >> 16;
|
|
uint8_t g = src_row[x] >> 8;
|
|
uint8_t b = src_row[x];
|
|
|
|
if (drm_format == DRM_FORMAT_RGB888) {
|
|
dst_row[x * 3 + 2] = r;
|
|
dst_row[x * 3 + 1] = g;
|
|
dst_row[x * 3 + 0] = b;
|
|
} else {
|
|
dst_row[x * 3 + 2] = b;
|
|
dst_row[x * 3 + 1] = g;
|
|
dst_row[x * 3 + 0] = r;
|
|
}
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* 32 bpp RGB
|
|
*
|
|
* RGBX8888: [31:0] R:G:B:x 8:8:8:8 little endian
|
|
* RGBA8888: [31:0] R:G:B:A 8:8:8:8 little endian
|
|
*
|
|
* BGRX8888: [31:0] B:G:R:x 8:8:8:8 little endian
|
|
* BGRA8888: [31:0] B:G:R:A 8:8:8:8 little endian
|
|
*
|
|
* XRGB8888: [31:0] x:R:G:B 8:8:8:8 little endian
|
|
* ARGB8888: [31:0] A:R:G:B 8:8:8:8 little endian
|
|
*
|
|
* XBGR8888: [31:0] x:B:G:R 8:8:8:8 little endian
|
|
* ABGR8888: [31:0] A:B:G:R 8:8:8:8 little endian
|
|
*/
|
|
static struct client_buffer *
|
|
rgba8888_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
static const int swizzles[][4] = {
|
|
{ 3, 2, 1, 0 }, /* RGBX8888, RGBA8888 */
|
|
{ 1, 2, 3, 0 }, /* BGRX8888, BGRA8888 */
|
|
{ 2, 1, 0, 3 }, /* XRGB8888, ARGB8888 */
|
|
{ 0, 1, 2, 3 }, /* XBGR8888, ABGR8888 */
|
|
};
|
|
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
bool is_opaque;
|
|
int idx, x, y;
|
|
uint32_t a;
|
|
|
|
switch (drm_format) {
|
|
case DRM_FORMAT_RGBX8888:
|
|
is_opaque = true;
|
|
idx = 0;
|
|
break;
|
|
case DRM_FORMAT_RGBA8888:
|
|
is_opaque = false;
|
|
idx = 0;
|
|
break;
|
|
case DRM_FORMAT_BGRX8888:
|
|
is_opaque = true;
|
|
idx = 1;
|
|
break;
|
|
case DRM_FORMAT_BGRA8888:
|
|
is_opaque = false;
|
|
idx = 1;
|
|
break;
|
|
case DRM_FORMAT_XRGB8888:
|
|
is_opaque = true;
|
|
idx = 2;
|
|
break;
|
|
case DRM_FORMAT_ARGB8888:
|
|
is_opaque = false;
|
|
idx = 2;
|
|
break;
|
|
case DRM_FORMAT_XBGR8888:
|
|
is_opaque = true;
|
|
idx = 3;
|
|
break;
|
|
case DRM_FORMAT_ABGR8888:
|
|
is_opaque = false;
|
|
idx = 3;
|
|
break;
|
|
default:
|
|
test_assert_not_reached("Invalid format!");
|
|
};
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
/* Store alpha as 0x00 to ensure the compositor correctly replaces it
|
|
* with 0xff. */
|
|
a = is_opaque ? 0x00 : 0xff;
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
uint32_t *dst_row =
|
|
(uint32_t*) buf->data + (buf->strides[0] / sizeof(uint32_t)) * y;
|
|
uint32_t *src_row = image_header_get_row_u32(&src, y);
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
uint32_t r = (src_row[x] >> 16) & 0xff;
|
|
uint32_t g = (src_row[x] >> 8) & 0xff;
|
|
uint32_t b = (src_row[x] >> 0) & 0xff;
|
|
|
|
dst_row[x] =
|
|
r << (swizzles[idx][0] * 8) |
|
|
g << (swizzles[idx][1] * 8) |
|
|
b << (swizzles[idx][2] * 8) |
|
|
a << (swizzles[idx][3] * 8);
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* 32 bpp RGB
|
|
*
|
|
* XRGB2101010: [31:0] x:R:G:B 2:10:10:10 little endian
|
|
* ARGB2101010: [31:0] A:R:G:B 2:10:10:10 little endian
|
|
*
|
|
* XBGR2101010: [31:0] x:B:G:R 2:10:10:10 little endian
|
|
* ABGR2101010: [31:0] A:B:G:R 2:10:10:10 little endian
|
|
*/
|
|
static struct client_buffer *
|
|
rgba2101010_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
int x, y;
|
|
uint32_t a;
|
|
|
|
test_assert_true(drm_format == DRM_FORMAT_XRGB2101010 ||
|
|
drm_format == DRM_FORMAT_ARGB2101010 ||
|
|
drm_format == DRM_FORMAT_XBGR2101010 ||
|
|
drm_format == DRM_FORMAT_ABGR2101010);
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
/* Store alpha as 0x0 to ensure the compositor correctly replaces it
|
|
* with 0x3. */
|
|
a = drm_format == DRM_FORMAT_XRGB2101010 ||
|
|
drm_format == DRM_FORMAT_XRGB2101010 ? 0x0 : 0x3;
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
uint32_t *dst_row =
|
|
(uint32_t*) buf->data + (buf->strides[0] / sizeof(uint32_t)) * y;
|
|
uint32_t *src_row = image_header_get_row_u32(&src, y);
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
uint32_t r = ((src_row[x] >> 16) & 0xff) << 2;
|
|
uint32_t g = ((src_row[x] >> 8) & 0xff) << 2;
|
|
uint32_t b = ((src_row[x] >> 0) & 0xff) << 2;
|
|
|
|
if (drm_format == DRM_FORMAT_XRGB2101010 ||
|
|
drm_format == DRM_FORMAT_ARGB2101010)
|
|
dst_row[x] = a << 30 | r << 20 | g << 10 | b;
|
|
else
|
|
dst_row[x] = a << 30 | b << 20 | g << 10 | r;
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* 64 bpp RGB
|
|
*
|
|
* XRGB16161616: [63:0] x:R:G:B 16:16:16:16 little endian
|
|
* ARGB16161616: [63:0] A:R:G:B 16:16:16:16 little endian
|
|
*
|
|
* XBGR16161616: [63:0] x:B:G:R 16:16:16:16 little endian
|
|
* ABGR16161616: [63:0] A:B:G:R 16:16:16:16 little endian
|
|
*/
|
|
static struct client_buffer *
|
|
rgba16161616_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
static const int swizzles[][4] = {
|
|
{ 2, 1, 0, 3 }, /* XRGB16161616, ARGB16161616 */
|
|
{ 0, 1, 2, 3 }, /* XBGR16161616, ABGR16161616 */
|
|
};
|
|
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
bool is_opaque;
|
|
int idx, x, y;
|
|
uint64_t a;
|
|
|
|
switch (drm_format) {
|
|
case DRM_FORMAT_XRGB16161616:
|
|
is_opaque = true;
|
|
idx = 0;
|
|
break;
|
|
case DRM_FORMAT_ARGB16161616:
|
|
is_opaque = false;
|
|
idx = 0;
|
|
break;
|
|
case DRM_FORMAT_XBGR16161616:
|
|
is_opaque = true;
|
|
idx = 1;
|
|
break;
|
|
case DRM_FORMAT_ABGR16161616:
|
|
is_opaque = false;
|
|
idx = 1;
|
|
break;
|
|
default:
|
|
test_assert_not_reached("Invalid format!");
|
|
};
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
/* Store alpha as 0x0000 to ensure the compositor correctly replaces it
|
|
* with 0xffff. */
|
|
a = is_opaque ? 0x0000 : 0xffff;
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
uint64_t *dst_row =
|
|
(uint64_t*) buf->data + (buf->strides[0] / sizeof(uint64_t)) * y;
|
|
uint32_t *src_row = image_header_get_row_u32(&src, y);
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
uint64_t r = ((src_row[x] >> 16) & 0xff) << 8;
|
|
uint64_t g = ((src_row[x] >> 8) & 0xff) << 8;
|
|
uint64_t b = ((src_row[x] >> 0) & 0xff) << 8;
|
|
|
|
dst_row[x] =
|
|
r << (swizzles[idx][0] * 16) |
|
|
g << (swizzles[idx][1] * 16) |
|
|
b << (swizzles[idx][2] * 16) |
|
|
a << (swizzles[idx][3] * 16);
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/* Convert an IEEE 754-2008 binary32 value to binary16 bits. Doesn't bother
|
|
* supporting Inf, Nan or subnormal numbers. Simply return signed 0 if there's
|
|
* an underflow due to the loss of precision. */
|
|
static uint16_t
|
|
binary16_from_binary32(float binary32)
|
|
{
|
|
uint32_t bits;
|
|
uint16_t sign, significand, exponent;
|
|
|
|
memcpy(&bits, &binary32, 4);
|
|
|
|
sign = bits >> 31;
|
|
exponent = (bits >> 23) & 0xff;
|
|
significand = (bits >> 13) & 0x3ff;
|
|
|
|
if (exponent >= 103)
|
|
return sign << 15 | (exponent - 112) << 10 | significand;
|
|
else
|
|
return sign << 15;
|
|
}
|
|
|
|
/*
|
|
* Floating point 64bpp RGB
|
|
* IEEE 754-2008 binary16 half-precision float
|
|
* [15:0] sign:exponent:mantissa 1:5:10
|
|
*
|
|
* XRGB16161616F: [63:0] x:R:G:B 16:16:16:16 little endian
|
|
* ARGB16161616F: [63:0] A:R:G:B 16:16:16:16 little endian
|
|
*
|
|
* XBGR16161616F: [63:0] x:B:G:R 16:16:16:16 little endian
|
|
* ABGR16161616F: [63:0] A:B:G:R 16:16:16:16 little endian
|
|
*/
|
|
static struct client_buffer *
|
|
rgba16161616f_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
static const int swizzles[][4] = {
|
|
{ 2, 1, 0, 3 }, /* XRGB16161616F, ARGB16161616F */
|
|
{ 0, 1, 2, 3 }, /* XBGR16161616F, ABGR16161616F */
|
|
};
|
|
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
bool is_opaque;
|
|
int idx, x, y;
|
|
uint64_t a;
|
|
|
|
switch (drm_format) {
|
|
case DRM_FORMAT_XRGB16161616F:
|
|
is_opaque = true;
|
|
idx = 0;
|
|
break;
|
|
case DRM_FORMAT_ARGB16161616F:
|
|
is_opaque = false;
|
|
idx = 0;
|
|
break;
|
|
case DRM_FORMAT_XBGR16161616F:
|
|
is_opaque = true;
|
|
idx = 1;
|
|
break;
|
|
case DRM_FORMAT_ABGR16161616F:
|
|
is_opaque = false;
|
|
idx = 1;
|
|
break;
|
|
default:
|
|
test_assert_not_reached("Invalid format!");
|
|
};
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
/* Store alpha as 0.0 to ensure the compositor correctly replaces it
|
|
* with 1.0. */
|
|
a = is_opaque ?
|
|
binary16_from_binary32(0.0f) :
|
|
binary16_from_binary32(1.0f);
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
uint64_t *dst_row =
|
|
(uint64_t*) buf->data + (buf->strides[0] / sizeof(uint64_t)) * y;
|
|
uint32_t *src_row = image_header_get_row_u32(&src, y);
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
uint64_t r = ((src_row[x] >> 16) & 0xff) << 8;
|
|
uint64_t g = ((src_row[x] >> 8) & 0xff) << 8;
|
|
uint64_t b = ((src_row[x] >> 0) & 0xff) << 8;
|
|
r = binary16_from_binary32(r / 65535.0f);
|
|
g = binary16_from_binary32(g / 65535.0f);
|
|
b = binary16_from_binary32(b / 65535.0f);
|
|
|
|
dst_row[x] =
|
|
r << (swizzles[idx][0] * 16) |
|
|
g << (swizzles[idx][1] * 16) |
|
|
b << (swizzles[idx][2] * 16) |
|
|
a << (swizzles[idx][3] * 16);
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* Based on Rec. ITU-R BT.709-6
|
|
*
|
|
* This is intended to be obvious and accurate, not fast.
|
|
*/
|
|
static void
|
|
x8r8g8b8_to_ycbcr8_bt709(uint32_t xrgb,
|
|
uint8_t *y_out, uint8_t *cb_out, uint8_t *cr_out)
|
|
{
|
|
double y, cb, cr;
|
|
double r = (xrgb >> 16) & 0xff;
|
|
double g = (xrgb >> 8) & 0xff;
|
|
double b = (xrgb >> 0) & 0xff;
|
|
|
|
/* normalize to [0.0, 1.0] */
|
|
r /= 255.0;
|
|
g /= 255.0;
|
|
b /= 255.0;
|
|
|
|
/* Y normalized to [0.0, 1.0], Cb and Cr [-0.5, 0.5] */
|
|
y = 0.2126 * r + 0.7152 * g + 0.0722 * b;
|
|
cr = (r - y) / 1.5748;
|
|
cb = (b - y) / 1.8556;
|
|
|
|
/* limited range quantization to 8 bit */
|
|
*y_out = round(219.0 * y + 16.0);
|
|
if (cr_out)
|
|
*cr_out = round(224.0 * cr + 128.0);
|
|
if (cb_out)
|
|
*cb_out = round(224.0 * cb + 128.0);
|
|
}
|
|
|
|
/*
|
|
* Same as above but for conversion to 16-bit Y'CbCr formats. 'depth' can be set
|
|
* to any value in the range [9, 16]. If 'depth' is less than 16, components are
|
|
* aligned to the most significant bit with the least significant bits set to 0.
|
|
*/
|
|
static void
|
|
x8r8g8b8_to_ycbcr16_bt709(uint32_t xrgb, int depth,
|
|
uint16_t *y_out, uint16_t *cb_out, uint16_t *cr_out)
|
|
{
|
|
uint16_t d;
|
|
double y, cb, cr;
|
|
double r = (xrgb >> 16) & 0xff;
|
|
double g = (xrgb >> 8) & 0xff;
|
|
double b = (xrgb >> 0) & 0xff;
|
|
|
|
/* Rec. ITU-R BT.709-6 defines D as 1 or 4 for 8-bit or 10-bit
|
|
* quantization respectively. We extrapolate here to [9, 16]-bit depths
|
|
* by setting D to 2^(depth - 8). */
|
|
test_assert_int_ge(depth, 9);
|
|
test_assert_int_le(depth, 16);
|
|
d = 1 << (depth - 8);
|
|
|
|
/* normalize to [0.0, 1.0] */
|
|
r /= 255.0;
|
|
g /= 255.0;
|
|
b /= 255.0;
|
|
|
|
/* Y normalized to [0.0, 1.0], Cb and Cr [-0.5, 0.5] */
|
|
y = 0.2126 * r + 0.7152 * g + 0.0722 * b;
|
|
cr = (r - y) / 1.5748;
|
|
cb = (b - y) / 1.8556;
|
|
|
|
/* limited range quantization to [9, 16]-bit aligned to the MSB */
|
|
*y_out = (uint16_t) round((219.0 * y + 16.0) * d) << (16 - depth);
|
|
if (cr_out)
|
|
*cr_out = (uint16_t)
|
|
round((224.0 * cr + 128.0) * d) << (16 - depth);
|
|
if (cb_out)
|
|
*cb_out = (uint16_t)
|
|
round((224.0 * cb + 128.0) * d) << (16 - depth);
|
|
}
|
|
|
|
/*
|
|
* 3 plane YCbCr
|
|
* plane 0: Y plane, [7:0] Y
|
|
* plane 1: Cb plane, [7:0] Cb
|
|
* plane 2: Cr plane, [7:0] Cr
|
|
*
|
|
* YUV420: 2x2 subsampled Cb (1) and Cr (2) planes
|
|
*
|
|
* YVU420: 2x2 subsampled Cr (1) and Cb (2) planes
|
|
*
|
|
* YUV444: no subsampling Cb (1) and Cr (2) planes
|
|
|
|
* YVU444: no subsampling Cr (1) and Cb (2) planes
|
|
*/
|
|
static struct client_buffer *
|
|
y_u_v_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
int x, y;
|
|
uint32_t *rgb_row;
|
|
uint8_t *y_base;
|
|
uint8_t *u_base;
|
|
uint8_t *v_base;
|
|
uint8_t *y_row;
|
|
uint8_t *u_row;
|
|
uint8_t *v_row;
|
|
uint32_t argb;
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
y_base = buf->data + buf->offsets[0];
|
|
switch (drm_format) {
|
|
case DRM_FORMAT_YUV420:
|
|
case DRM_FORMAT_YUV422:
|
|
case DRM_FORMAT_YUV444:
|
|
u_base = buf->data + buf->offsets[1];
|
|
v_base = buf->data + buf->offsets[2];
|
|
break;
|
|
case DRM_FORMAT_YVU420:
|
|
case DRM_FORMAT_YVU422:
|
|
case DRM_FORMAT_YVU444:
|
|
v_base = buf->data + buf->offsets[1];
|
|
u_base = buf->data + buf->offsets[2];
|
|
break;
|
|
}
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
rgb_row = image_header_get_row_u32(&src, y / 2 * 2);
|
|
y_row = y_base + y * buf->strides[0];
|
|
|
|
switch (drm_format) {
|
|
case DRM_FORMAT_YUV420:
|
|
case DRM_FORMAT_YUV422:
|
|
case DRM_FORMAT_YUV444:
|
|
u_row = u_base + (y / pixel_format_vsub(buf->fmt, 1)) * buf->strides[1];
|
|
v_row = v_base + (y / pixel_format_vsub(buf->fmt, 1)) * buf->strides[2];
|
|
break;
|
|
case DRM_FORMAT_YVU420:
|
|
case DRM_FORMAT_YVU422:
|
|
case DRM_FORMAT_YVU444:
|
|
v_row = v_base + (y / pixel_format_vsub(buf->fmt, 1)) * buf->strides[1];
|
|
u_row = u_base + (y / pixel_format_vsub(buf->fmt, 1)) * buf->strides[2];
|
|
break;
|
|
}
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
/*
|
|
* Sub-sample the source image instead, so that U and V
|
|
* sub-sampling does not require proper
|
|
* filtering/averaging/siting.
|
|
*/
|
|
argb = *(rgb_row + x / 2 * 2);
|
|
|
|
/*
|
|
* A stupid way of "sub-sampling" chroma. This does not
|
|
* do the necessary filtering/averaging/siting or
|
|
* alternate Cb/Cr rows.
|
|
*/
|
|
if ((y & (pixel_format_vsub(buf->fmt, 1) - 1)) == 0 &&
|
|
(x & (pixel_format_hsub(buf->fmt, 1) - 1)) == 0) {
|
|
x8r8g8b8_to_ycbcr8_bt709(argb, y_row + x,
|
|
u_row + x / pixel_format_hsub(buf->fmt, 1),
|
|
v_row + x / pixel_format_hsub(buf->fmt, 1));
|
|
} else {
|
|
x8r8g8b8_to_ycbcr8_bt709(argb, y_row + x,
|
|
NULL, NULL);
|
|
}
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* 2 plane YCbCr
|
|
*
|
|
* NV12: plane 0 = Y plane, [7:0] Y
|
|
* plane 1 = Cr:Cb plane, [15:0] Cr:Cb little endian
|
|
* 2x2 subsampled Cr:Cb plane
|
|
*
|
|
* NV21: plane 0 = Y plane, [7:0] Y
|
|
* plane 1 = Cb:Cr plane, [15:0] Cb:Cr little endian
|
|
* 2x2 subsampled Cb:Cr plane
|
|
*/
|
|
static struct client_buffer *
|
|
nv12_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
static const int swizzles[][2] = {
|
|
{ 0, 1 }, /* NV12 */
|
|
{ 1, 0 } /* NV21 */
|
|
};
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
int idx, x, y;
|
|
uint32_t *rgb_row;
|
|
uint8_t *y_base;
|
|
uint16_t *uv_base;
|
|
uint8_t *y_row;
|
|
uint16_t *uv_row;
|
|
uint32_t argb;
|
|
uint8_t cr;
|
|
uint8_t cb;
|
|
|
|
switch (drm_format) {
|
|
case DRM_FORMAT_NV12:
|
|
idx = 0;
|
|
break;
|
|
case DRM_FORMAT_NV21:
|
|
idx = 1;
|
|
break;
|
|
default:
|
|
test_assert_not_reached("Invalid format!");
|
|
};
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
y_base = buf->data + buf->offsets[0];
|
|
uv_base = (uint16_t *)(buf->data + buf->offsets[1]);
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
rgb_row = image_header_get_row_u32(&src, y / 2 * 2);
|
|
y_row = y_base + y * buf->strides[0];
|
|
uv_row = uv_base + (y / 2) * (buf->strides[1] / sizeof(uint16_t));
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
/*
|
|
* Sub-sample the source image instead, so that U and V
|
|
* sub-sampling does not require proper
|
|
* filtering/averaging/siting.
|
|
*/
|
|
argb = *(rgb_row + x / 2 * 2);
|
|
|
|
/*
|
|
* A stupid way of "sub-sampling" chroma. This does not
|
|
* do the necessary filtering/averaging/siting.
|
|
*/
|
|
if ((y & 1) == 0 && (x & 1) == 0) {
|
|
x8r8g8b8_to_ycbcr8_bt709(argb, y_row + x,
|
|
&cb, &cr);
|
|
*(uv_row + x / 2) =
|
|
((uint16_t) cr << (swizzles[idx][1] * 8)) |
|
|
((uint16_t) cb << (swizzles[idx][0] * 8));
|
|
} else {
|
|
x8r8g8b8_to_ycbcr8_bt709(argb, y_row + x,
|
|
NULL, NULL);
|
|
}
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* 2 plane YCbCr
|
|
*
|
|
* NV16: plane 0 = Y plane, [7:0] Y
|
|
* plane 1 = Cr:Cb plane, [15:0] Cr:Cb little endian
|
|
* 2x1 subsampled Cr:Cb plane
|
|
*
|
|
* NV61: plane 0 = Y plane, [7:0] Y
|
|
* plane 1 = Cb:Cr plane, [15:0] Cb:Cr little endian
|
|
* 2x1 subsampled Cb:Cr plane
|
|
*/
|
|
static struct client_buffer *
|
|
nv16_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
static const int swizzles[][2] = {
|
|
{ 0, 1 }, /* NV16 */
|
|
{ 1, 0 } /* NV61 */
|
|
};
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
int idx, x, y;
|
|
uint32_t *rgb_row;
|
|
uint8_t *y_base;
|
|
uint16_t *uv_base;
|
|
uint8_t *y_row;
|
|
uint16_t *uv_row;
|
|
uint32_t argb;
|
|
uint8_t cr;
|
|
uint8_t cb;
|
|
|
|
switch (drm_format) {
|
|
case DRM_FORMAT_NV16:
|
|
idx = 0;
|
|
break;
|
|
case DRM_FORMAT_NV61:
|
|
idx = 1;
|
|
break;
|
|
default:
|
|
test_assert_not_reached("Invalid format!");
|
|
};
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
y_base = buf->data + buf->offsets[0];
|
|
uv_base = (uint16_t *)(buf->data + buf->offsets[1]);
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
rgb_row = image_header_get_row_u32(&src, y / 2 * 2);
|
|
y_row = y_base + y * buf->strides[0];
|
|
uv_row = uv_base + y * (buf->strides[1] / sizeof(uint16_t));
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
/*
|
|
* 2x2 sub-sample the source image to get the same
|
|
* result as the other YUV variants, so we can use the
|
|
* same reference image for checking.
|
|
*/
|
|
argb = *(rgb_row + x / 2 * 2);
|
|
|
|
/*
|
|
* A stupid way of "sub-sampling" chroma. This does not
|
|
* do the necessary filtering/averaging/siting.
|
|
*/
|
|
if ((x & 1) == 0) {
|
|
x8r8g8b8_to_ycbcr8_bt709(argb, y_row + x,
|
|
&cb, &cr);
|
|
*(uv_row + x / 2) =
|
|
((uint16_t) cr << (swizzles[idx][1] * 8)) |
|
|
((uint16_t) cb << (swizzles[idx][0] * 8));
|
|
} else {
|
|
x8r8g8b8_to_ycbcr8_bt709(argb, y_row + x,
|
|
NULL, NULL);
|
|
}
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* 2 plane YCbCr
|
|
*
|
|
* NV24: plane 0 = Y plane, [7:0] Y
|
|
* plane 1 = Cr:Cb plane, [15:0] Cr:Cb little endian
|
|
* non-subsampled Cr:Cb plane
|
|
*
|
|
* NV42: plane 0 = Y plane, [7:0] Y
|
|
* plane 1 = Cb:Cr plane, [15:0] Cb:Cr little endian
|
|
* non-subsampled Cb:Cr plane
|
|
*/
|
|
static struct client_buffer *
|
|
nv24_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
static const int swizzles[][2] = {
|
|
{ 0, 1 }, /* NV24 */
|
|
{ 1, 0 } /* NV42 */
|
|
};
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
int idx, x, y;
|
|
uint32_t *rgb_row;
|
|
uint8_t *y_base;
|
|
uint16_t *uv_base;
|
|
uint8_t *y_row;
|
|
uint16_t *uv_row;
|
|
uint32_t argb;
|
|
uint8_t cr;
|
|
uint8_t cb;
|
|
|
|
switch (drm_format) {
|
|
case DRM_FORMAT_NV24:
|
|
idx = 0;
|
|
break;
|
|
case DRM_FORMAT_NV42:
|
|
idx = 1;
|
|
break;
|
|
default:
|
|
test_assert_not_reached("Invalid format!");
|
|
};
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
y_base = buf->data + buf->offsets[0];
|
|
uv_base = (uint16_t *)(buf->data + buf->offsets[1]);
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
rgb_row = image_header_get_row_u32(&src, y / 2 * 2);
|
|
y_row = y_base + y * buf->strides[0];
|
|
uv_row = uv_base + y * (buf->strides[1] / sizeof(uint16_t));
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
/*
|
|
* 2x2 sub-sample the source image to get the same
|
|
* result as the other YUV variants, so we can use the
|
|
* same reference image for checking.
|
|
*/
|
|
argb = *(rgb_row + x / 2 * 2);
|
|
|
|
x8r8g8b8_to_ycbcr8_bt709(argb, y_row + x,
|
|
&cb, &cr);
|
|
*(uv_row + x) =
|
|
((uint16_t) cr << (swizzles[idx][1] * 8)) |
|
|
((uint16_t) cb << (swizzles[idx][0] * 8));
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* Packed YCbCr
|
|
*
|
|
* YUYV: [31:0] Cr0:Y1:Cb0:Y0 8:8:8:8 little endian
|
|
* 2x1 subsampled Cr:Cb plane
|
|
*
|
|
* YVYU: [31:0] Cb0:Y1:Cr0:Y0 8:8:8:8 little endian
|
|
* 2x1 subsampled Cb:Cr plane
|
|
*
|
|
* UYVY: [31:0] Y1:Cr0:Y0:Cb0 8:8:8:8 little endian
|
|
* 2x1 subsampled Cr:Cb plane
|
|
*
|
|
* VYUY: [31:0] Y1:Cb0:Y0:Cr0 8:8:8:8 little endian
|
|
* 2x1 subsampled Cb:Cr plane
|
|
*/
|
|
static struct client_buffer *
|
|
yuyv_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
static const int swizzles[][4] = {
|
|
{ 0, 1, 2, 3 }, /* YUYV */
|
|
{ 0, 3, 2, 1 }, /* YVYU */
|
|
{ 1, 0, 3, 2 }, /* UYVY */
|
|
{ 1, 2, 3, 0 } /* VYUY */
|
|
};
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
int idx, x, y;
|
|
uint32_t *rgb_row;
|
|
uint32_t *yuv_base;
|
|
uint32_t *yuv_row;
|
|
uint8_t cr;
|
|
uint8_t cb;
|
|
uint8_t y0;
|
|
|
|
switch (drm_format) {
|
|
case DRM_FORMAT_YUYV:
|
|
idx = 0;
|
|
break;
|
|
case DRM_FORMAT_YVYU:
|
|
idx = 1;
|
|
break;
|
|
case DRM_FORMAT_UYVY:
|
|
idx = 2;
|
|
break;
|
|
case DRM_FORMAT_VYUY:
|
|
idx = 3;
|
|
break;
|
|
default:
|
|
test_assert_not_reached("Invalid format!");
|
|
};
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
yuv_base = buf->data;
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
rgb_row = image_header_get_row_u32(&src, y / 2 * 2);
|
|
yuv_row = yuv_base + y * (buf->strides[0] / sizeof(uint32_t));
|
|
|
|
for (x = 0; x < src.width; x += 2) {
|
|
/*
|
|
* Sub-sample the source image instead, so that U and V
|
|
* sub-sampling does not require proper
|
|
* filtering/averaging/siting.
|
|
*/
|
|
x8r8g8b8_to_ycbcr8_bt709(*(rgb_row + x), &y0, &cb, &cr);
|
|
*(yuv_row + x / 2) =
|
|
((uint32_t)cr << (swizzles[idx][3] * 8)) |
|
|
((uint32_t)y0 << (swizzles[idx][2] * 8)) |
|
|
((uint32_t)cb << (swizzles[idx][1] * 8)) |
|
|
((uint32_t)y0 << (swizzles[idx][0] * 8));
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* Packed YCbCr
|
|
*
|
|
* XYUV8888: [31:0] X:Y:Cb:Cr 8:8:8:8 little endian
|
|
* full resolution chroma
|
|
*/
|
|
static struct client_buffer *
|
|
xyuv8888_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
int x, y;
|
|
uint32_t *rgb_row;
|
|
uint32_t *yuv_base;
|
|
uint32_t *yuv_row;
|
|
uint8_t cr;
|
|
uint8_t cb;
|
|
uint8_t y0;
|
|
|
|
test_assert_enum(drm_format, DRM_FORMAT_XYUV8888);
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
yuv_base = buf->data;
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
rgb_row = image_header_get_row_u32(&src, y / 2 * 2);
|
|
yuv_row = yuv_base + y * (buf->strides[0] / sizeof(uint32_t));
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
/*
|
|
* 2x2 sub-sample the source image to get the same
|
|
* result as the other YUV variants, so we can use the
|
|
* same reference image for checking.
|
|
*/
|
|
x8r8g8b8_to_ycbcr8_bt709(*(rgb_row + x / 2 * 2), &y0, &cb, &cr);
|
|
/*
|
|
* The unused byte is intentionally set to "garbage"
|
|
* to catch any accidental use of it in the compositor.
|
|
*/
|
|
*(yuv_row + x) =
|
|
((uint32_t)x << 24) |
|
|
((uint32_t)y0 << 16) |
|
|
((uint32_t)cb << 8) |
|
|
((uint32_t)cr << 0);
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
* 2 plane YCbCr MSB aligned
|
|
*
|
|
* P016: index 0 = Y plane, [15:0] Y little endian
|
|
* index 1 = Cr:Cb plane, [31:0] Cr:Cb [16:16] little endian
|
|
* 2x2 subsampled Cr:Cb plane 16 bits per channel
|
|
*
|
|
* P012: index 0 = Y plane, [15:0] Y:x [12:4] little endian
|
|
* index 1 = Cr:Cb plane, [31:0] Cr:x:Cb:x [12:4:12:4] little endian
|
|
* 2x2 subsampled Cr:Cb plane 12 bits per channel
|
|
*
|
|
* P010: index 0 = Y plane, [15:0] Y:x [10:6] little endian
|
|
* index 1 = Cr:Cb plane, [31:0] Cr:x:Cb:x [10:6:10:6] little endian
|
|
* 2x2 subsampled Cr:Cb plane 10 bits per channel
|
|
*/
|
|
static struct client_buffer *
|
|
p016_create_buffer(struct client *client,
|
|
uint32_t drm_format,
|
|
enum buffer_type type,
|
|
pixman_image_t *rgb_image)
|
|
{
|
|
struct image_header src = image_header_from(rgb_image);
|
|
struct client_buffer_create_data args = create_init(drm_format, type, &src);
|
|
struct client_buffer *buf;
|
|
int depth, x, y;
|
|
uint32_t *rgb_row;
|
|
uint16_t *y_base;
|
|
uint32_t *uv_base;
|
|
uint16_t *y_row;
|
|
uint32_t *uv_row;
|
|
uint32_t argb;
|
|
uint16_t cr;
|
|
uint16_t cb;
|
|
|
|
switch (drm_format) {
|
|
case DRM_FORMAT_P016:
|
|
depth = 16;
|
|
break;
|
|
case DRM_FORMAT_P012:
|
|
depth = 12;
|
|
break;
|
|
case DRM_FORMAT_P010:
|
|
depth = 10;
|
|
break;
|
|
default:
|
|
test_assert_not_reached("Invalid format!");
|
|
};
|
|
|
|
buf = client_buffer_create(client, &args);
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
y_base = (uint16_t *)(buf->data + buf->offsets[0]);
|
|
uv_base = (uint32_t *)(buf->data + buf->offsets[1]);
|
|
|
|
client_buffer_util_maybe_sync_dmabuf_start(buf);
|
|
for (y = 0; y < src.height; y++) {
|
|
rgb_row = image_header_get_row_u32(&src, y / 2 * 2);
|
|
y_row = y_base + y * (buf->strides[0] / sizeof(uint16_t));
|
|
uv_row = uv_base + (y / 2) * (buf->strides[1] / sizeof(uint32_t));
|
|
|
|
for (x = 0; x < src.width; x++) {
|
|
/*
|
|
* Sub-sample the source image instead, so that U and V
|
|
* sub-sampling does not require proper
|
|
* filtering/averaging/siting.
|
|
*/
|
|
argb = *(rgb_row + x / 2 * 2);
|
|
|
|
/*
|
|
* A stupid way of "sub-sampling" chroma. This does not
|
|
* do the necessary filtering/averaging/siting.
|
|
*/
|
|
if ((x & 1) == 0 && (y & 1) == 0) {
|
|
x8r8g8b8_to_ycbcr16_bt709(argb, depth,
|
|
y_row + x, &cb, &cr);
|
|
*(uv_row + x / 2) =
|
|
((uint32_t) cr << 16) |
|
|
((uint32_t) cb << 0);
|
|
} else {
|
|
x8r8g8b8_to_ycbcr16_bt709(argb, depth,
|
|
y_row + x, NULL, NULL);
|
|
}
|
|
}
|
|
}
|
|
client_buffer_util_maybe_sync_dmabuf_end(buf);
|
|
|
|
return buf;
|
|
}
|
|
|
|
static void
|
|
show_window_with_client_buffer(struct client *client, struct client_buffer *buf)
|
|
{
|
|
struct surface *surface = client->surface;
|
|
int done;
|
|
|
|
weston_test_move_surface(client->test->weston_test, surface->wl_surface,
|
|
4, 4);
|
|
wl_surface_attach(surface->wl_surface, buf->wl_buffer, 0, 0);
|
|
wl_surface_damage(surface->wl_surface, 0, 0, buf->width,
|
|
buf->height);
|
|
frame_callback_set(surface->wl_surface, &done);
|
|
wl_surface_commit(surface->wl_surface);
|
|
frame_callback_wait(client, &done);
|
|
}
|
|
|
|
static const struct client_buffer_case client_buffer_cases[] = {
|
|
#define FMT(x) DRM_FORMAT_ ##x, #x
|
|
/* RGB */
|
|
{ FMT(RGBX4444), 0, rgba4444_create_buffer },
|
|
{ FMT(RGBA4444), 0, rgba4444_create_buffer },
|
|
{ FMT(BGRX4444), 0, rgba4444_create_buffer },
|
|
{ FMT(BGRA4444), 0, rgba4444_create_buffer },
|
|
{ FMT(XRGB4444), 0, rgba4444_create_buffer },
|
|
{ FMT(ARGB4444), 0, rgba4444_create_buffer },
|
|
{ FMT(XBGR4444), 0, rgba4444_create_buffer },
|
|
{ FMT(ABGR4444), 0, rgba4444_create_buffer },
|
|
{ FMT(RGBX5551), 1, rgba5551_create_buffer },
|
|
{ FMT(RGBA5551), 1, rgba5551_create_buffer },
|
|
{ FMT(BGRX5551), 1, rgba5551_create_buffer },
|
|
{ FMT(BGRA5551), 1, rgba5551_create_buffer },
|
|
{ FMT(RGB565), 2, rgb565_create_buffer },
|
|
{ FMT(BGR565), 2, rgb565_create_buffer },
|
|
{ FMT(RGB888), 3, rgb888_create_buffer },
|
|
{ FMT(BGR888), 3, rgb888_create_buffer },
|
|
{ FMT(RGBX8888), 3, rgba8888_create_buffer },
|
|
{ FMT(RGBA8888), 3, rgba8888_create_buffer },
|
|
{ FMT(BGRX8888), 3, rgba8888_create_buffer },
|
|
{ FMT(BGRA8888), 3, rgba8888_create_buffer },
|
|
{ FMT(XRGB8888), 3, rgba8888_create_buffer },
|
|
{ FMT(ARGB8888), 3, rgba8888_create_buffer },
|
|
{ FMT(XBGR8888), 3, rgba8888_create_buffer },
|
|
{ FMT(ABGR8888), 3, rgba8888_create_buffer },
|
|
{ FMT(XRGB2101010), 3, rgba2101010_create_buffer },
|
|
{ FMT(ARGB2101010), 3, rgba2101010_create_buffer },
|
|
{ FMT(XBGR2101010), 3, rgba2101010_create_buffer },
|
|
{ FMT(ABGR2101010), 3, rgba2101010_create_buffer },
|
|
{ FMT(XRGB16161616), 3, rgba16161616_create_buffer },
|
|
{ FMT(ARGB16161616), 3, rgba16161616_create_buffer },
|
|
{ FMT(XBGR16161616), 3, rgba16161616_create_buffer },
|
|
{ FMT(ABGR16161616), 3, rgba16161616_create_buffer },
|
|
{ FMT(XRGB16161616F), 3, rgba16161616f_create_buffer },
|
|
{ FMT(ARGB16161616F), 3, rgba16161616f_create_buffer },
|
|
{ FMT(XBGR16161616F), 3, rgba16161616f_create_buffer },
|
|
{ FMT(ABGR16161616F), 3, rgba16161616f_create_buffer },
|
|
/* YUV */
|
|
{ FMT(YUV420), 4, y_u_v_create_buffer },
|
|
{ FMT(YVU420), 4, y_u_v_create_buffer },
|
|
{ FMT(YUV422), 4, y_u_v_create_buffer },
|
|
{ FMT(YVU422), 4, y_u_v_create_buffer },
|
|
{ FMT(YUV444), 4, y_u_v_create_buffer },
|
|
{ FMT(YVU444), 4, y_u_v_create_buffer },
|
|
{ FMT(NV12), 4, nv12_create_buffer },
|
|
{ FMT(NV21), 4, nv12_create_buffer },
|
|
{ FMT(NV16), 4, nv16_create_buffer },
|
|
{ FMT(NV61), 4, nv16_create_buffer },
|
|
{ FMT(NV24), 4, nv24_create_buffer },
|
|
{ FMT(NV42), 4, nv24_create_buffer },
|
|
{ FMT(YUYV), 4, yuyv_create_buffer },
|
|
{ FMT(YVYU), 4, yuyv_create_buffer },
|
|
{ FMT(UYVY), 4, yuyv_create_buffer },
|
|
{ FMT(VYUY), 4, yuyv_create_buffer },
|
|
{ FMT(XYUV8888), 4, xyuv8888_create_buffer },
|
|
{ FMT(P010), 5, p016_create_buffer },
|
|
{ FMT(P012), 5, p016_create_buffer },
|
|
{ FMT(P016), 5, p016_create_buffer },
|
|
#undef FMT
|
|
};
|
|
|
|
static enum test_result_code
|
|
test_client_buffer(const struct client_buffer_case *cb_case,
|
|
enum buffer_type type)
|
|
{
|
|
enum test_result_code res = RESULT_SKIP;
|
|
char *fname;
|
|
pixman_image_t *img;
|
|
struct client *client;
|
|
struct client_buffer *buf;
|
|
bool match;
|
|
|
|
/*
|
|
* Note for YUV formats:
|
|
*
|
|
* This test image is 256 x 256 pixels.
|
|
*
|
|
* Therefore this test does NOT exercise:
|
|
* - odd image dimensions
|
|
* - non-square image
|
|
* - row padding
|
|
* - unaligned row stride
|
|
* - different alignments or padding in sub-sampled planes
|
|
*
|
|
* The reason to not test these is that GL-renderer seems to be more
|
|
* or less broken.
|
|
*
|
|
* The source image is effectively further downscaled to 128 x 128
|
|
* before sampled and converted to 256 x 256 YUV, so that
|
|
* sub-sampling for U and V does not require proper algorithms.
|
|
* Therefore, this test also does not test:
|
|
* - chroma siting (chroma sample positioning)
|
|
*/
|
|
fname = image_filename("chocolate-cake");
|
|
img = load_image_from_png(fname);
|
|
free(fname);
|
|
test_assert_ptr_not_null(img);
|
|
|
|
client = create_client();
|
|
client->surface = create_test_surface(client);
|
|
|
|
buf = cb_case->create_buffer(client, cb_case->drm_format, type, img);
|
|
if (buf) {
|
|
show_window_with_client_buffer(client, buf);
|
|
|
|
match = verify_screen_content(client, "client-buffer",
|
|
cb_case->ref_seq_no, NULL, 0,
|
|
NULL);
|
|
res = match ? RESULT_OK : RESULT_FAIL;
|
|
|
|
client_buffer_util_destroy_buffer(buf);
|
|
}
|
|
|
|
pixman_image_unref(img);
|
|
client_destroy(client);
|
|
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
* We do not require any format to pass, unless we run in CI where
|
|
* WESTON_TEST_SKIP_IS_FAILURE is defined. In CI we require the hardcoded
|
|
* list of formats to be supported and correct. Outside of CI we might running
|
|
* with various graphics drivers with different supported formats, so we cannot
|
|
* require a big list of formats to succeed.
|
|
*
|
|
* Even if a format is not required to pass, if the format is detected as
|
|
* supported and the check with the format fails, the test will still fail.
|
|
*/
|
|
static bool
|
|
format_must_pass(uint32_t drm_format, const uint32_t *must_pass, const size_t num)
|
|
{
|
|
#if WESTON_TEST_SKIP_IS_FAILURE
|
|
if (!must_pass || num == 0)
|
|
return true;
|
|
|
|
for (size_t i = 0; i < num; i++)
|
|
if (must_pass[i] == drm_format)
|
|
return true;
|
|
#endif
|
|
|
|
return false;
|
|
}
|
|
|
|
static enum test_result_code
|
|
skip_is_just_fine(enum test_result_code c)
|
|
{
|
|
#if WESTON_TEST_SKIP_IS_FAILURE
|
|
if (c == RESULT_SKIP)
|
|
return RESULT_OK;
|
|
#endif
|
|
return c;
|
|
}
|
|
|
|
static enum test_result_code
|
|
this_is_an_unwanted_case(void)
|
|
{
|
|
#if WESTON_TEST_SKIP_IS_FAILURE
|
|
return RESULT_OK;
|
|
#else
|
|
return RESULT_SKIP;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Test that various SHM pixel formats result in correct coloring on screen.
|
|
*/
|
|
TEST_P(client_buffer_shm, client_buffer_cases)
|
|
{
|
|
const struct client_buffer_case *cb_case = data;
|
|
const struct setup_args *args = &my_setup_args[get_test_fixture_index()];
|
|
enum test_result_code res;
|
|
|
|
if (args->gl_force_import_yuv_fallback)
|
|
return this_is_an_unwanted_case();
|
|
|
|
testlog("%s: format %s\n", get_test_name(), cb_case->drm_format_name);
|
|
|
|
res = test_client_buffer(cb_case, BUFFER_TYPE_SHM);
|
|
if (res == RESULT_SKIP) {
|
|
test_assert_false(format_must_pass(cb_case->drm_format,
|
|
args->shm_format_must_pass,
|
|
args->shm_format_num));
|
|
}
|
|
|
|
return skip_is_just_fine(res);
|
|
}
|
|
|
|
/*
|
|
* Test that various DRM pixel formats result in correct coloring on screen.
|
|
*/
|
|
TEST_P(client_buffer_drm, client_buffer_cases)
|
|
{
|
|
const struct client_buffer_case *cb_case = data;
|
|
const struct setup_args *args = &my_setup_args[get_test_fixture_index()];
|
|
enum test_result_code res;
|
|
|
|
if (args->gl_force_import_yuv_fallback) {
|
|
const struct pixel_format_info *info;
|
|
|
|
info = pixel_format_get_info(cb_case->drm_format);
|
|
if (info->color_model != COLOR_MODEL_YUV)
|
|
return this_is_an_unwanted_case();
|
|
}
|
|
|
|
testlog("%s: format %s\n", get_test_name(), cb_case->drm_format_name);
|
|
|
|
if (!client_buffer_util_is_dmabuf_supported()) {
|
|
testlog("%s: Skipped: udmabuf not supported\n", get_test_name());
|
|
return RESULT_SKIP;
|
|
}
|
|
|
|
res = test_client_buffer(cb_case, BUFFER_TYPE_DMABUF);
|
|
if (res == RESULT_SKIP) {
|
|
test_assert_false(format_must_pass(cb_case->drm_format,
|
|
args->dmabuf_format_must_pass,
|
|
args->dmabuf_format_num));
|
|
}
|
|
|
|
return skip_is_just_fine(res);
|
|
}
|