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

Add support for the YUV format P010

Signed-off-by: Louis Chauvet <louis.chau...@bootlin.com>
---
 drivers/gpu/drm/vkms/tests/vkms_format_test.c | 103 +++++++++++++-------------
 drivers/gpu/drm/vkms/vkms_formats.c           |  26 ++++---
 drivers/gpu/drm/vkms/vkms_formats.h           |   4 +-
 3 files changed, 68 insertions(+), 65 deletions(-)

diff --git a/drivers/gpu/drm/vkms/tests/vkms_format_test.c 
b/drivers/gpu/drm/vkms/tests/vkms_format_test.c
index 2e1daef94831..272e18a82f9c 100644
--- a/drivers/gpu/drm/vkms/tests/vkms_format_test.c
+++ b/drivers/gpu/drm/vkms/tests/vkms_format_test.c
@@ -23,7 +23,7 @@ MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");
  *     machine endianness
  */
 struct pixel_yuv_u8 {
-       u8 y, u, v;
+       u16 y, u, v;
 };
 
 /*
@@ -64,7 +64,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)
         *
@@ -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,13 +201,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",   { 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 }},
+               }
        },
 };
 
@@ -236,7 +236,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",
diff --git a/drivers/gpu/drm/vkms/vkms_formats.c 
b/drivers/gpu/drm/vkms/vkms_formats.c
index 5106441f916b..261e822e9618 100644
--- a/drivers/gpu/drm/vkms/vkms_formats.c
+++ b/drivers/gpu/drm/vkms/vkms_formats.c
@@ -279,16 +279,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) +
@@ -310,7 +311,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
@@ -504,8 +505,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)
@@ -549,8 +550,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) {
@@ -690,9 +692,9 @@ pixel_read_line_t get_pixel_read_line_function(u32 format)
        case DRM_FORMAT_BGRX8888:
                return &BGRX8888_read_line;
        case DRM_FORMAT_RGB888:
-               return RGB888_read_line;
+               return &RGB888_read_line;
        case DRM_FORMAT_BGR888:
-               return BGR888_read_line;
+               return &BGR888_read_line;
        case DRM_FORMAT_ARGB16161616:
                return &ARGB16161616_read_line;
        case DRM_FORMAT_ABGR16161616:
diff --git a/drivers/gpu/drm/vkms/vkms_formats.h 
b/drivers/gpu/drm/vkms/vkms_formats.h
index b4fe62ab9c65..eeb208cdd6b1 100644
--- a/drivers/gpu/drm/vkms/vkms_formats.h
+++ b/drivers/gpu/drm/vkms/vkms_formats.h
@@ -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_ */

-- 
2.49.0

Reply via email to