Unverified Commit 7766ae8d authored by Louis Chauvet's avatar Louis Chauvet
Browse files

drm/vkms: Change YUV helpers to support u16 inputs for conversion 



Some YUV format uses 16 bit values, so change the helper function for
conversion to support those new formats.

Reviewed-by: default avatarMaíra Canal <mcanal@igalia.com>
Acked-by: default avatarDaniel Stone <daniels@collabora.com>
Link: https://lore.kernel.org/r/20250703-b4-new-color-formats-v7-6-15fd8fd2e15c@bootlin.com


Signed-off-by: default avatarLouis Chauvet <louis.chauvet@bootlin.com>
parent 50c58f4f

drivers/gpu/drm/vkms/tests/vkms_format_test.c

+71 −72
Original line number Diff line number Diff line
@@ -14,20 +14,20 @@ 
MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");



/**

 * struct pixel_yuv_u8 - Internal representation of a pixel color.

 * @y: Luma value, stored in 8 bits, without padding, using

 * struct pixel_yuv_u16 - Internal representation of a pixel color.

 * @y: Luma value, stored in 16 bits, without padding, using

 *     machine endianness

 * @u: Blue difference chroma value, stored in 8 bits, without padding, using

 * @u: Blue difference chroma value, stored in 16 bits, without padding, using

 *     machine endianness

 * @v: Red difference chroma value, stored in 8 bits, without padding, using

 * @v: Red difference chroma value, stored in 16 bits, without padding, using

 *     machine endianness

 */

struct pixel_yuv_u8 {

	u8 y, u, v;

struct pixel_yuv_u16 {

	u16 y, u, v;

};



/*

 * struct yuv_u8_to_argb_u16_case - Reference values to test the color

 * struct yuv_u16_to_argb_u16_case - Reference values to test the color

 * conversions in VKMS between YUV to ARGB

 *

 * @encoding: Encoding used to convert RGB to YUV
@@ -39,13 +39,13 @@ struct pixel_yuv_u8 { 
 * @format_pair.yuv: Same color as @format_pair.rgb, but converted to

 *                   YUV using @encoding and @range.

 */

struct yuv_u8_to_argb_u16_case {

struct yuv_u16_to_argb_u16_case {

	enum drm_color_encoding encoding;

	enum drm_color_range range;

	size_t n_colors;

	struct format_pair {

		char *name;

		struct pixel_yuv_u8 yuv;

		struct pixel_yuv_u16 yuv;

		struct pixel_argb_u16 argb;

	} colors[TEST_BUFF_SIZE];

};
@@ -57,14 +57,14 @@ struct yuv_u8_to_argb_u16_case { 
 * For more information got to the docs:

 * https://colour.readthedocs.io/en/master/generated/colour.RGB_to_YCbCr.html

 */

static struct yuv_u8_to_argb_u16_case yuv_u8_to_argb_u16_cases[] = {

static struct yuv_u16_to_argb_u16_case yuv_u16_to_argb_u16_cases[] = {

	/*

	 * colour.RGB_to_YCbCr(<rgb color in 16 bit form>,

	 *                     K=colour.WEIGHTS_YCBCR["ITU-R BT.601"],

	 *                     in_bits = 16,

	 *                     in_legal = False,

	 *                     in_int = True,

	 *                     out_bits = 8,

	 *                     out_bits = 16,

	 *                     out_legal = False,

	 *                     out_int = True)

	 *
@@ -76,13 +76,13 @@ static struct yuv_u8_to_argb_u16_case yuv_u8_to_argb_u16_cases[] = { 
		.range = DRM_COLOR_YCBCR_FULL_RANGE,

		.n_colors = 6,

		.colors = {

			{ "white", { 0xff, 0x80, 0x80 }, { 0xffff, 0xffff, 0xffff, 0xffff }},

			{ "gray",  { 0x80, 0x80, 0x80 }, { 0xffff, 0x8080, 0x8080, 0x8080 }},

			{ "black", { 0x00, 0x80, 0x80 }, { 0xffff, 0x0000, 0x0000, 0x0000 }},

			{ "red",   { 0x4c, 0x55, 0xff }, { 0xffff, 0xffff, 0x0000, 0x0000 }},

			{ "green", { 0x96, 0x2c, 0x15 }, { 0xffff, 0x0000, 0xffff, 0x0000 }},

			{ "blue",  { 0x1d, 0xff, 0x6b }, { 0xffff, 0x0000, 0x0000, 0xffff }},

		},

			{ "white", { 0xffff, 0x8000, 0x8000 }, { 0xffff, 0xffff, 0xffff, 0xffff }},

			{ "gray",  { 0x8080, 0x8000, 0x8000 }, { 0xffff, 0x8080, 0x8080, 0x8080 }},

			{ "black", { 0x0000, 0x8000, 0x8000 }, { 0xffff, 0x0000, 0x0000, 0x0000 }},

			{ "red",   { 0x4c8b, 0x54ce, 0xffff }, { 0xffff, 0xffff, 0x0000, 0x0000 }},

			{ "green", { 0x9645, 0x2b33, 0x14d1 }, { 0xffff, 0x0000, 0xffff, 0x0000 }},

			{ "blue",  { 0x1d2f, 0xffff, 0x6b2f }, { 0xffff, 0x0000, 0x0000, 0xffff }},

		}

	},

	/*

	 * colour.RGB_to_YCbCr(<rgb color in 16 bit form>,
@@ -90,7 +90,7 @@ static struct yuv_u8_to_argb_u16_case yuv_u8_to_argb_u16_cases[] = { 
	 *                     in_bits = 16,

	 *                     in_legal = False,

	 *                     in_int = True,

	 *                     out_bits = 8,

	 *                     out_bits = 16,

	 *                     out_legal = True,

	 *                     out_int = True)

	 * Tests cases for color conversion generated by converting RGB
@@ -101,13 +101,13 @@ static struct yuv_u8_to_argb_u16_case yuv_u8_to_argb_u16_cases[] = { 
		.range = DRM_COLOR_YCBCR_LIMITED_RANGE,

		.n_colors = 6,

		.colors = {

			{ "white", { 0xeb, 0x80, 0x80 }, { 0xffff, 0xffff, 0xffff, 0xffff }},

			{ "gray",  { 0x7e, 0x80, 0x80 }, { 0xffff, 0x8080, 0x8080, 0x8080 }},

			{ "black", { 0x10, 0x80, 0x80 }, { 0xffff, 0x0000, 0x0000, 0x0000 }},

			{ "red",   { 0x51, 0x5a, 0xf0 }, { 0xffff, 0xffff, 0x0000, 0x0000 }},

			{ "green", { 0x91, 0x36, 0x22 }, { 0xffff, 0x0000, 0xffff, 0x0000 }},

			{ "blue",  { 0x29, 0xf0, 0x6e }, { 0xffff, 0x0000, 0x0000, 0xffff }},

		},

			{ "white", { 0xeb00, 0x8000, 0x8000 }, { 0xffff, 0xffff, 0xffff, 0xffff }},

			{ "gray",  { 0x7dee, 0x8000, 0x8000 }, { 0xffff, 0x8080, 0x8080, 0x8080 }},

			{ "black", { 0x1000, 0x8000, 0x8000 }, { 0xffff, 0x0000, 0x0000, 0x0000 }},

			{ "red",   { 0x517b, 0x5a34, 0xf000 }, { 0xffff, 0xffff, 0x0000, 0x0000 }},

			{ "green", { 0x908e, 0x35cc, 0x2237 }, { 0xffff, 0x0000, 0xffff, 0x0000 }},

			{ "blue",  { 0x28f7, 0xf000, 0x6dc9 }, { 0xffff, 0x0000, 0x0000, 0xffff }},

		}

	},

	/*

	 * colour.RGB_to_YCbCr(<rgb color in 16 bit form>,
@@ -115,7 +115,7 @@ static struct yuv_u8_to_argb_u16_case yuv_u8_to_argb_u16_cases[] = { 
	 *                     in_bits = 16,

	 *                     in_legal = False,

	 *                     in_int = True,

	 *                     out_bits = 8,

	 *                     out_bits = 16,

	 *                     out_legal = False,

	 *                     out_int = True)

	 * Tests cases for color conversion generated by converting RGB
@@ -126,21 +126,21 @@ static struct yuv_u8_to_argb_u16_case yuv_u8_to_argb_u16_cases[] = { 
		.range = DRM_COLOR_YCBCR_FULL_RANGE,

		.n_colors = 6,

		.colors = {

			{ "white", { 0xff, 0x80, 0x80 }, { 0xffff, 0xffff, 0xffff, 0xffff }},

			{ "gray",  { 0x80, 0x80, 0x80 }, { 0xffff, 0x8080, 0x8080, 0x8080 }},

			{ "black", { 0x00, 0x80, 0x80 }, { 0xffff, 0x0000, 0x0000, 0x0000 }},

			{ "red",   { 0x36, 0x63, 0xff }, { 0xffff, 0xffff, 0x0000, 0x0000 }},

			{ "green", { 0xb6, 0x1e, 0x0c }, { 0xffff, 0x0000, 0xffff, 0x0000 }},

			{ "blue",  { 0x12, 0xff, 0x74 }, { 0xffff, 0x0000, 0x0000, 0xffff }},

		},

			{ "white", { 0xffff, 0x8000, 0x8000 }, { 0xffff, 0xffff, 0xffff, 0xffff }},

			{ "gray",  { 0x8080, 0x8000, 0x8000 }, { 0xffff, 0x8080, 0x8080, 0x8080 }},

			{ "black", { 0x0000, 0x8000, 0x8000 }, { 0xffff, 0x0000, 0x0000, 0x0000 }},

			{ "red",   { 0x366d, 0x62ac, 0xffff }, { 0xffff, 0xffff, 0x0000, 0x0000 }},

			{ "green", { 0xb717, 0x1d55, 0x0bbd }, { 0xffff, 0x0000, 0xffff, 0x0000 }},

			{ "blue",  { 0x127c, 0xffff, 0x7443 }, { 0xffff, 0x0000, 0x0000, 0xffff }},

		}

	},

	/*

	 * colour.RGB_to_YCbCr(<rgb color in 16 bit form>,

	 *                     K=colour.WEIGHTS_YCBCR["ITU-R BT.709"],

	 *                     in_bits = 16,

	 *                     int_legal = False,

	 *                     in_legal = False,

	 *                     in_int = True,

	 *                     out_bits = 8,

	 *                     out_bits = 16,

	 *                     out_legal = True,

	 *                     out_int = True)

	 * Tests cases for color conversion generated by converting RGB
@@ -151,13 +151,13 @@ static struct yuv_u8_to_argb_u16_case yuv_u8_to_argb_u16_cases[] = { 
		.range = DRM_COLOR_YCBCR_LIMITED_RANGE,

		.n_colors = 6,

		.colors = {

			{ "white", { 0xeb, 0x80, 0x80 }, { 0xffff, 0xffff, 0xffff, 0xffff }},

			{ "gray",  { 0x7e, 0x80, 0x80 }, { 0xffff, 0x8080, 0x8080, 0x8080 }},

			{ "black", { 0x10, 0x80, 0x80 }, { 0xffff, 0x0000, 0x0000, 0x0000 }},

			{ "red",   { 0x3f, 0x66, 0xf0 }, { 0xffff, 0xffff, 0x0000, 0x0000 }},

			{ "green", { 0xad, 0x2a, 0x1a }, { 0xffff, 0x0000, 0xffff, 0x0000 }},

			{ "blue",  { 0x20, 0xf0, 0x76 }, { 0xffff, 0x0000, 0x0000, 0xffff }},

		},

			{ "white", { 0xeb00, 0x8000, 0x8000 }, { 0xffff, 0xffff, 0xffff, 0xffff }},

			{ "gray",  { 0x7dee, 0x8000, 0x8000 }, { 0xffff, 0x8080, 0x8080, 0x8080 }},

			{ "black", { 0x1000, 0x8000, 0x8000 }, { 0xffff, 0x0000, 0x0000, 0x0000 }},

			{ "red",   { 0x3e8f, 0x6656, 0xf000 }, { 0xffff, 0xffff, 0x0000, 0x0000 }},

			{ "green", { 0xaca1, 0x29aa, 0x1a45 }, { 0xffff, 0x0000, 0xffff, 0x0000 }},

			{ "blue",  { 0x1fd0, 0xf000, 0x75bb }, { 0xffff, 0x0000, 0x0000, 0xffff }},

		}

	},

	/*

	 * colour.RGB_to_YCbCr(<rgb color in 16 bit form>,
@@ -165,7 +165,7 @@ static struct yuv_u8_to_argb_u16_case yuv_u8_to_argb_u16_cases[] = { 
	 *                     in_bits = 16,

	 *                     in_legal = False,

	 *                     in_int = True,

	 *                     out_bits = 8,

	 *                     out_bits = 16,

	 *                     out_legal = False,

	 *                     out_int = True)

	 * Tests cases for color conversion generated by converting RGB
@@ -176,13 +176,13 @@ static struct yuv_u8_to_argb_u16_case yuv_u8_to_argb_u16_cases[] = { 
		.range = DRM_COLOR_YCBCR_FULL_RANGE,

		.n_colors = 6,

		.colors = {

			{ "white", { 0xff, 0x80, 0x80 }, { 0xffff, 0xffff, 0xffff, 0xffff }},

			{ "gray",  { 0x80, 0x80, 0x80 }, { 0xffff, 0x8080, 0x8080, 0x8080 }},

			{ "black", { 0x00, 0x80, 0x80 }, { 0xffff, 0x0000, 0x0000, 0x0000 }},

			{ "red",   { 0x43, 0x5c, 0xff }, { 0xffff, 0xffff, 0x0000, 0x0000 }},

			{ "green", { 0xad, 0x24, 0x0b }, { 0xffff, 0x0000, 0xffff, 0x0000 }},

			{ "blue",  { 0x0f, 0xff, 0x76 }, { 0xffff, 0x0000, 0x0000, 0xffff }},

		},

			{ "white", { 0xffff, 0x8000, 0x8000 }, { 0xffff, 0xffff, 0xffff, 0xffff }},

			{ "gray",  { 0x8080, 0x8000, 0x8000 }, { 0xffff, 0x8080, 0x8080, 0x8080 }},

			{ "black", { 0x0000, 0x8000, 0x8000 }, { 0xffff, 0x0000, 0x0000, 0x0000 }},

			{ "red",   { 0x4340, 0x5c41, 0xffff }, { 0xffff, 0xffff, 0x0000, 0x0000 }},

			{ "green", { 0xad91, 0x23bf, 0x0a4c }, { 0xffff, 0x0000, 0xffff, 0x0000 }},

			{ "blue",  { 0x0f2e, 0xffff, 0x75b5 }, { 0xffff, 0x0000, 0x0000, 0xffff }},

		}

	},

	/*

	 * colour.RGB_to_YCbCr(<rgb color in 16 bit form>,
@@ -190,7 +190,7 @@ static struct yuv_u8_to_argb_u16_case yuv_u8_to_argb_u16_cases[] = { 
	 *                     in_bits = 16,

	 *                     in_legal = False,

	 *                     in_int = True,

	 *                     out_bits = 8,

	 *                     out_bits = 16,

	 *                     out_legal = True,

	 *                     out_int = True)

	 * Tests cases for color conversion generated by converting RGB
@@ -201,32 +201,30 @@ static struct yuv_u8_to_argb_u16_case yuv_u8_to_argb_u16_cases[] = { 
		.range = DRM_COLOR_YCBCR_LIMITED_RANGE,

		.n_colors = 6,

		.colors = {

			{ "white", { 0xeb, 0x80, 0x80 }, { 0xffff, 0xffff, 0xffff, 0xffff }},

			{ "gray",  { 0x7e, 0x80, 0x80 }, { 0xffff, 0x8080, 0x8080, 0x8080 }},

			{ "black", { 0x10, 0x80, 0x80 }, { 0xffff, 0x0000, 0x0000, 0x0000 }},

			{ "red",   { 0x4a, 0x61, 0xf0 }, { 0xffff, 0xffff, 0x0000, 0x0000 }},

			{ "green", { 0xa4, 0x2f, 0x19 }, { 0xffff, 0x0000, 0xffff, 0x0000 }},

			{ "blue",  { 0x1d, 0xf0, 0x77 }, { 0xffff, 0x0000, 0x0000, 0xffff }},

		},

			{ "white", { 0xeb00, 0x8000, 0x8000 }, { 0xffff, 0xffff, 0xffff, 0xffff }},

			{ "gray",  { 0x7dee, 0x8000, 0x8000 }, { 0xffff, 0x8080, 0x8080, 0x8080 }},

			{ "black", { 0x1000, 0x8000, 0x8000 }, { 0xffff, 0x0000, 0x0000, 0x0000 }},

			{ "red",   { 0x4988, 0x60b9, 0xf000 }, { 0xffff, 0xffff, 0x0000, 0x0000 }},

			{ "green", { 0xa47b, 0x2f47, 0x1902 }, { 0xffff, 0x0000, 0xffff, 0x0000 }},

			{ "blue",  { 0x1cfd, 0xf000, 0x76fe }, { 0xffff, 0x0000, 0x0000, 0xffff }},

		}

	},

};



/*

 * vkms_format_test_yuv_u8_to_argb_u16 - Testing the conversion between YUV

 * vkms_format_test_yuv_u16_to_argb_u16 - Testing the conversion between YUV

 * colors to ARGB colors in VKMS

 *

 * This test will use the functions get_conversion_matrix_to_argb_u16 and

 * argb_u16_from_yuv888 to convert YUV colors (stored in

 * yuv_u8_to_argb_u16_cases) into ARGB colors.

 * argb_u16_from_yuv161616 to convert YUV colors (stored in

 * yuv_u16_to_argb_u16_cases) into ARGB colors.

 *

 * The conversion between YUV and RGB is not totally reversible, so there may be

 * some difference between the expected value and the result.

 * In addition, there may be some rounding error as the input color is 8 bits

 * and output color is 16 bits.

 */

static void vkms_format_test_yuv_u8_to_argb_u16(struct kunit *test)

static void vkms_format_test_yuv_u16_to_argb_u16(struct kunit *test)

{

	const struct yuv_u8_to_argb_u16_case *param = test->param_value;

	const struct yuv_u16_to_argb_u16_case *param = test->param_value;

	struct pixel_argb_u16 argb;



	for (size_t i = 0; i < param->n_colors; i++) {
@@ -236,7 +234,8 @@ static void vkms_format_test_yuv_u8_to_argb_u16(struct kunit *test) 
		get_conversion_matrix_to_argb_u16

			(DRM_FORMAT_NV12, param->encoding, param->range, &matrix);



		argb = argb_u16_from_yuv888(color->yuv.y, color->yuv.u, color->yuv.v, &matrix);

		argb = argb_u16_from_yuv161616(&matrix, color->yuv.y, color->yuv.u,

					       color->yuv.v);



		KUNIT_EXPECT_LE_MSG(test, abs_diff(argb.a, color->argb.a), 0x1ff,

				    "On the A channel of the color %s expected 0x%04x, got 0x%04x",
@@ -253,19 +252,19 @@ static void vkms_format_test_yuv_u8_to_argb_u16(struct kunit *test) 
	}

}



static void vkms_format_test_yuv_u8_to_argb_u16_case_desc(struct yuv_u8_to_argb_u16_case *t,

static void vkms_format_test_yuv_u16_to_argb_u16_case_desc(struct yuv_u16_to_argb_u16_case *t,

							   char *desc)

{

	snprintf(desc, KUNIT_PARAM_DESC_SIZE, "%s - %s",

		 drm_get_color_encoding_name(t->encoding), drm_get_color_range_name(t->range));

}



KUNIT_ARRAY_PARAM(yuv_u8_to_argb_u16, yuv_u8_to_argb_u16_cases,

		  vkms_format_test_yuv_u8_to_argb_u16_case_desc

KUNIT_ARRAY_PARAM(yuv_u16_to_argb_u16, yuv_u16_to_argb_u16_cases,

		  vkms_format_test_yuv_u16_to_argb_u16_case_desc

);



static struct kunit_case vkms_format_test_cases[] = {

	KUNIT_CASE_PARAM(vkms_format_test_yuv_u8_to_argb_u16, yuv_u8_to_argb_u16_gen_params),

	KUNIT_CASE_PARAM(vkms_format_test_yuv_u16_to_argb_u16, yuv_u16_to_argb_u16_gen_params),

	{}

};

drivers/gpu/drm/vkms/vkms_formats.c

+12 −10
Original line number Diff line number Diff line
@@ -269,16 +269,17 @@ static struct pixel_argb_u16 argb_u16_from_BGR565(const __le16 *pixel) 
	return out_pixel;

}



VISIBLE_IF_KUNIT struct pixel_argb_u16 argb_u16_from_yuv888(u8 y, u8 channel_1, u8 channel_2,

							    const struct conversion_matrix *matrix)

VISIBLE_IF_KUNIT

struct pixel_argb_u16 argb_u16_from_yuv161616(const struct conversion_matrix *matrix,

					      u16 y, u16 channel_1, u16 channel_2)

{

	u16 r, g, b;

	s64 fp_y, fp_channel_1, fp_channel_2;

	s64 fp_r, fp_g, fp_b;



	fp_y = drm_int2fixp(((int)y - matrix->y_offset) * 257);

	fp_channel_1 = drm_int2fixp(((int)channel_1 - 128) * 257);

	fp_channel_2 = drm_int2fixp(((int)channel_2 - 128) * 257);

	fp_y = drm_int2fixp((int)y - matrix->y_offset * 257);

	fp_channel_1 = drm_int2fixp((int)channel_1 - 128 * 257);

	fp_channel_2 = drm_int2fixp((int)channel_2 - 128 * 257);



	fp_r = drm_fixp_mul(matrix->matrix[0][0], fp_y) +

	       drm_fixp_mul(matrix->matrix[0][1], fp_channel_1) +
@@ -300,7 +301,7 @@ VISIBLE_IF_KUNIT struct pixel_argb_u16 argb_u16_from_yuv888(u8 y, u8 channel_1, 


	return argb_u16_from_u16161616(0xffff, r, g, b);

}

EXPORT_SYMBOL_IF_KUNIT(argb_u16_from_yuv888);

EXPORT_SYMBOL_IF_KUNIT(argb_u16_from_yuv161616);



/**

 * READ_LINE() - Generic generator for a read_line function which can be used for format with one
@@ -498,8 +499,8 @@ static void semi_planar_yuv_read_line(const struct vkms_plane_state *plane, int 
	const struct conversion_matrix *conversion_matrix = &plane->conversion_matrix;



	for (int i = 0; i < count; i++) {

		*out_pixel = argb_u16_from_yuv888(y_plane[0], uv_plane[0], uv_plane[1],

						  conversion_matrix);

		*out_pixel = argb_u16_from_yuv161616(conversion_matrix, y_plane[0] * 257,

						     uv_plane[0] * 257, uv_plane[1] * 257);

		out_pixel += 1;

		y_plane += step_y;

		if ((i + subsampling_offset + 1) % subsampling == 0)
@@ -543,8 +544,9 @@ static void planar_yuv_read_line(const struct vkms_plane_state *plane, int x_sta 
	const struct conversion_matrix *conversion_matrix = &plane->conversion_matrix;



	for (int i = 0; i < count; i++) {

		*out_pixel = argb_u16_from_yuv888(*y_plane, *channel_1_plane, *channel_2_plane,

						  conversion_matrix);

		*out_pixel = argb_u16_from_yuv161616(conversion_matrix,

						     *y_plane * 257, *channel_1_plane * 257,

						     *channel_2_plane * 257);

		out_pixel += 1;

		y_plane += step_y;

		if ((i + subsampling_offset + 1) % subsampling == 0) {

drivers/gpu/drm/vkms/vkms_formats.h

+2 −2
Original line number Diff line number Diff line
@@ -14,8 +14,8 @@ void get_conversion_matrix_to_argb_u16(u32 format, enum drm_color_encoding encod 
				       struct conversion_matrix *matrix);



#if IS_ENABLED(CONFIG_KUNIT)

struct pixel_argb_u16 argb_u16_from_yuv888(u8 y, u8 channel_1, u8 channel_2,

					   const struct conversion_matrix *matrix);

struct pixel_argb_u16 argb_u16_from_yuv161616(const struct conversion_matrix *matrix,

					      u16 y, u16 channel_1, u16 channel_2);

#endif



#endif /* _VKMS_FORMATS_H_ */