weston/tests/yuv-buffer-test.c

495 lines
12 KiB
C
Raw Normal View History

/*
* 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 <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <math.h>
#include <unistd.h>
#include "weston-test-client-helper.h"
#include "weston-test-fixture-compositor.h"
#include "shared/os-compatibility.h"
#include "shared/weston-drm-fourcc.h"
#include "shared/xalloc.h"
static enum test_result_code
fixture_setup(struct weston_test_harness *harness)
{
struct compositor_setup setup;
compositor_setup_defaults(&setup);
setup.renderer = RENDERER_GL;
setup.width = 324;
setup.height = 264;
setup.shell = SHELL_TEST_DESKTOP;
gl-renderer: implement intermediate framebuffer (shadow) Proper color management will need blending done with linear light pixel values, that is, EOTF applied before blending, and then inverse-EOTF applied for scanout after blending. The simplest way to set that up is to use an intemediate framebuffer a.k.a shadow buffer containing the composited image in linear light values, then blit from that to the actual framebuffer. This patch implements the shadow buffer, but the linear light blending is left for another patch. This allows GL-renderer to turn WESTON_CAP_COLOR_OPS on. Half-float is chosen as the buffer format because linear light values require more bits to encode with sufficient precision than the usual non-linear pixel values. v2: Use /* */ instead of // (Pekka) Rename fbo and tex to shadow_{fbo,tex} (Pekka) Check for OpenGLES capabilities before creating shadow_{tex,fbo} (Pekka) Signed-off-by: Harish Krupo <harishkrupo@gmail.com> v3: Rebased. Simplified GL version checks (Sebastian) Apply changes from "libweston: add color ops cap and bool renderer shadow buffer" Renamed supports_half_float_texture to has_gl_half_float to follow the existing naming pattern. Introduce gl_renderer_create_shadow_16f(). Undo moving of glViewport() call. Replace half_float_texture_enabled with shadow_exists(). Introduce struct gl_output_state_shadow. Assert no resizing with shadow. Fix triangle fan debug. Rename repaint_from_texture() to blit_shadow_to_output(). Rewrite commit message because linear light blending is not implemented in this patch. Fix blit_shadow_to_output() for scaled/transformed outputs and remove redundant code. Fix has_gl_half_float determination. v4: Disable blending in blit_shadow. (Daniel) Port to gl_renderer_get_program(). Make a generic fbo-texture struct with parameterized format. (Daniel) Change has_gl_half_float into gl_half_float_type. Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
2019-04-18 19:15:48 +03:00
setup.logging_scopes = "log,gl-shader-generator";
return weston_test_harness_execute_as_client(harness, &setup);
}
DECLARE_FIXTURE_SETUP(fixture_setup);
struct yuv_buffer {
void *data;
size_t bytes;
struct wl_buffer *proxy;
int width;
int height;
};
struct yuv_case {
uint32_t drm_format;
const char *drm_format_name;
struct yuv_buffer *(*create_buffer)(struct client *client,
uint32_t drm_format,
pixman_image_t *rgb_image);
};
static struct yuv_buffer *
yuv_buffer_create(struct client *client,
size_t bytes,
int width,
int height,
int stride_bytes,
uint32_t drm_format)
{
struct wl_shm_pool *pool;
struct yuv_buffer *buf;
int fd;
buf = xzalloc(sizeof *buf);
buf->bytes = bytes;
buf->width = width;
buf->height = height;
fd = os_create_anonymous_file(buf->bytes);
assert(fd >= 0);
buf->data = mmap(NULL, buf->bytes,
PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (buf->data == MAP_FAILED) {
close(fd);
assert(buf->data != MAP_FAILED);
}
pool = wl_shm_create_pool(client->wl_shm, fd, buf->bytes);
buf->proxy = wl_shm_pool_create_buffer(pool, 0, buf->width, buf->height,
stride_bytes, drm_format);
wl_shm_pool_destroy(pool);
close(fd);
return buf;
}
static void
yuv_buffer_destroy(struct yuv_buffer *buf)
{
wl_buffer_destroy(buf->proxy);
assert(munmap(buf->data, buf->bytes) == 0);
free(buf);
}
/*
* Based on Rec. ITU-R BT.601-7
*
* This is intended to be obvious and accurate, not fast.
*/
static void
x8r8g8b8_to_ycbcr8_bt601(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.299 * r + 0.587 * g + 0.114 * b;
cr = (r - y) / 1.402;
cb = (b - y) / 1.772;
/* 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);
}
/*
* 3 plane YCbCr
* plane 0: Y plane, [7:0] Y
* plane 1: Cb plane, [7:0] Cb
* plane 2: Cr plane, [7:0] Cr
* 2x2 subsampled Cb (1) and Cr (2) planes
*/
static struct yuv_buffer *
yuv420_create_buffer(struct client *client,
uint32_t drm_format,
pixman_image_t *rgb_image)
{
struct yuv_buffer *buf;
size_t bytes;
int width;
int height;
int x, y;
void *rgb_pixels;
int rgb_stride_bytes;
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;
assert(drm_format == DRM_FORMAT_YUV420);
width = pixman_image_get_width(rgb_image);
height = pixman_image_get_height(rgb_image);
rgb_pixels = pixman_image_get_data(rgb_image);
rgb_stride_bytes = pixman_image_get_stride(rgb_image);
/* Full size Y, quarter U and V */
bytes = width * height + (width / 2) * (height / 2) * 2;
buf = yuv_buffer_create(client, bytes, width, height, width, drm_format);
y_base = buf->data;
u_base = y_base + width * height;
v_base = u_base + (width / 2) * (height / 2);
for (y = 0; y < height; y++) {
rgb_row = rgb_pixels + (y / 2 * 2) * rgb_stride_bytes;
y_row = y_base + y * width;
u_row = u_base + (y / 2) * (width / 2);
v_row = v_base + (y / 2) * (width / 2);
for (x = 0; x < 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 & 1) == 0 && (x & 1) == 0) {
x8r8g8b8_to_ycbcr8_bt601(argb, y_row + x,
u_row + x / 2,
v_row + x / 2);
} else {
x8r8g8b8_to_ycbcr8_bt601(argb, y_row + x,
NULL, NULL);
}
}
}
return buf;
}
/*
* 2 plane YCbCr
* plane 0 = Y plane, [7:0] Y
* plane 1 = Cr:Cb plane, [15:0] Cr:Cb little endian
* 2x2 subsampled Cr:Cb plane
*/
static struct yuv_buffer *
nv12_create_buffer(struct client *client,
uint32_t drm_format,
pixman_image_t *rgb_image)
{
struct yuv_buffer *buf;
size_t bytes;
int width;
int height;
int x, y;
void *rgb_pixels;
int rgb_stride_bytes;
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;
assert(drm_format == DRM_FORMAT_NV12);
width = pixman_image_get_width(rgb_image);
height = pixman_image_get_height(rgb_image);
rgb_pixels = pixman_image_get_data(rgb_image);
rgb_stride_bytes = pixman_image_get_stride(rgb_image);
/* Full size Y, quarter UV */
bytes = width * height + (width / 2) * (height / 2) * sizeof(uint16_t);
buf = yuv_buffer_create(client, bytes, width, height, width, drm_format);
y_base = buf->data;
uv_base = (uint16_t *)(y_base + width * height);
for (y = 0; y < height; y++) {
rgb_row = rgb_pixels + (y / 2 * 2) * rgb_stride_bytes;
y_row = y_base + y * width;
uv_row = uv_base + (y / 2) * (width / 2);
for (x = 0; x < 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_bt601(argb, y_row + x,
&cb, &cr);
*(uv_row + x / 2) = ((uint16_t)cr << 8) | cb;
} else {
x8r8g8b8_to_ycbcr8_bt601(argb, y_row + x,
NULL, NULL);
}
}
}
return buf;
}
/*
* Packed YCbCr
*
* [31:0] Cr0:Y1:Cb0:Y0 8:8:8:8 little endian
* 2x1 subsampled Cr:Cb plane
*/
static struct yuv_buffer *
yuyv_create_buffer(struct client *client,
uint32_t drm_format,
pixman_image_t *rgb_image)
{
struct yuv_buffer *buf;
size_t bytes;
int width;
int height;
int x, y;
void *rgb_pixels;
int rgb_stride_bytes;
uint32_t *rgb_row;
uint32_t *yuv_base;
uint32_t *yuv_row;
uint8_t cr;
uint8_t cb;
uint8_t y0;
assert(drm_format == DRM_FORMAT_YUYV);
width = pixman_image_get_width(rgb_image);
height = pixman_image_get_height(rgb_image);
rgb_pixels = pixman_image_get_data(rgb_image);
rgb_stride_bytes = pixman_image_get_stride(rgb_image);
/* Full size Y, horizontally subsampled UV, 2 pixels in 32 bits */
bytes = width / 2 * height * sizeof(uint32_t);
buf = yuv_buffer_create(client, bytes, width, height, width / 2 * sizeof(uint32_t), drm_format);
yuv_base = buf->data;
for (y = 0; y < height; y++) {
rgb_row = rgb_pixels + (y / 2 * 2) * rgb_stride_bytes;
yuv_row = yuv_base + y * (width / 2);
for (x = 0; x < 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_bt601(*(rgb_row + x), &y0, &cb, &cr);
*(yuv_row + x / 2) =
((uint32_t)cr << 24) |
((uint32_t)y0 << 16) |
((uint32_t)cb << 8) |
((uint32_t)y0 << 0);
}
}
return buf;
}
/*
* Packed YCbCr
*
* [31:0] X:Y:Cb:Cr 8:8:8:8 little endian
* full resolution chroma
*/
static struct yuv_buffer *
xyuv8888_create_buffer(struct client *client,
uint32_t drm_format,
pixman_image_t *rgb_image)
{
struct yuv_buffer *buf;
size_t bytes;
int width;
int height;
int x, y;
void *rgb_pixels;
int rgb_stride_bytes;
uint32_t *rgb_row;
uint32_t *yuv_base;
uint32_t *yuv_row;
uint8_t cr;
uint8_t cb;
uint8_t y0;
assert(drm_format == DRM_FORMAT_XYUV8888);
width = pixman_image_get_width(rgb_image);
height = pixman_image_get_height(rgb_image);
rgb_pixels = pixman_image_get_data(rgb_image);
rgb_stride_bytes = pixman_image_get_stride(rgb_image);
/* Full size, 32 bits per pixel */
bytes = width * height * sizeof(uint32_t);
buf = yuv_buffer_create(client, bytes, width, height, width * sizeof(uint32_t), drm_format);
yuv_base = buf->data;
for (y = 0; y < height; y++) {
rgb_row = rgb_pixels + (y / 2 * 2) * rgb_stride_bytes;
yuv_row = yuv_base + y * width;
for (x = 0; x < 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_bt601(*(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);
}
}
return buf;
}
static void
show_window_with_yuv(struct client *client, struct yuv_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->proxy, 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 yuv_case yuv_cases[] = {
#define FMT(x) DRM_FORMAT_ ##x, #x
{ FMT(YUV420), yuv420_create_buffer },
{ FMT(NV12), nv12_create_buffer },
{ FMT(YUYV), yuyv_create_buffer },
{ FMT(XYUV8888), xyuv8888_create_buffer },
#undef FMT
};
/*
* Test that various YUV pixel formats result in correct coloring on screen.
*/
TEST_P(yuv_buffer_shm, yuv_cases)
{
const struct yuv_case *my_case = data;
char *fname;
pixman_image_t *img;
struct client *client;
struct yuv_buffer *buf;
bool match;
testlog("%s: format %s\n", get_test_name(), my_case->drm_format_name);
/*
* 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);
assert(img);
client = create_client();
client->surface = create_test_surface(client);
buf = my_case->create_buffer(client, my_case->drm_format, img);
show_window_with_yuv(client, buf);
match = verify_screen_content(client, "yuv-buffer", 0, NULL, 0);
assert(match);
yuv_buffer_destroy(buf);
pixman_image_unref(img);
client_destroy(client);
}