1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | |
3 | #include <linux/kernel.h> |
4 | #include <linux/minmax.h> |
5 | |
6 | #include <drm/drm_blend.h> |
7 | #include <drm/drm_rect.h> |
8 | #include <drm/drm_fixed.h> |
9 | |
10 | #include "vkms_formats.h" |
11 | |
12 | static size_t pixel_offset(const struct vkms_frame_info *frame_info, int x, int y) |
13 | { |
14 | return frame_info->offset + (y * frame_info->pitch) |
15 | + (x * frame_info->cpp); |
16 | } |
17 | |
18 | /* |
19 | * packed_pixels_addr - Get the pointer to pixel of a given pair of coordinates |
20 | * |
21 | * @frame_info: Buffer metadata |
22 | * @x: The x(width) coordinate of the 2D buffer |
23 | * @y: The y(Heigth) coordinate of the 2D buffer |
24 | * |
25 | * Takes the information stored in the frame_info, a pair of coordinates, and |
26 | * returns the address of the first color channel. |
27 | * This function assumes the channels are packed together, i.e. a color channel |
28 | * comes immediately after another in the memory. And therefore, this function |
29 | * doesn't work for YUV with chroma subsampling (e.g. YUV420 and NV21). |
30 | */ |
31 | static void *packed_pixels_addr(const struct vkms_frame_info *frame_info, |
32 | int x, int y) |
33 | { |
34 | size_t offset = pixel_offset(frame_info, x, y); |
35 | |
36 | return (u8 *)frame_info->map[0].vaddr + offset; |
37 | } |
38 | |
39 | static void *get_packed_src_addr(const struct vkms_frame_info *frame_info, int y) |
40 | { |
41 | int x_src = frame_info->src.x1 >> 16; |
42 | int y_src = y - frame_info->rotated.y1 + (frame_info->src.y1 >> 16); |
43 | |
44 | return packed_pixels_addr(frame_info, x: x_src, y: y_src); |
45 | } |
46 | |
47 | static int get_x_position(const struct vkms_frame_info *frame_info, int limit, int x) |
48 | { |
49 | if (frame_info->rotation & (DRM_MODE_REFLECT_X | DRM_MODE_ROTATE_270)) |
50 | return limit - x - 1; |
51 | return x; |
52 | } |
53 | |
54 | static void ARGB8888_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel) |
55 | { |
56 | /* |
57 | * The 257 is the "conversion ratio". This number is obtained by the |
58 | * (2^16 - 1) / (2^8 - 1) division. Which, in this case, tries to get |
59 | * the best color value in a pixel format with more possibilities. |
60 | * A similar idea applies to others RGB color conversions. |
61 | */ |
62 | out_pixel->a = (u16)src_pixels[3] * 257; |
63 | out_pixel->r = (u16)src_pixels[2] * 257; |
64 | out_pixel->g = (u16)src_pixels[1] * 257; |
65 | out_pixel->b = (u16)src_pixels[0] * 257; |
66 | } |
67 | |
68 | static void XRGB8888_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel) |
69 | { |
70 | out_pixel->a = (u16)0xffff; |
71 | out_pixel->r = (u16)src_pixels[2] * 257; |
72 | out_pixel->g = (u16)src_pixels[1] * 257; |
73 | out_pixel->b = (u16)src_pixels[0] * 257; |
74 | } |
75 | |
76 | static void ARGB16161616_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel) |
77 | { |
78 | u16 *pixels = (u16 *)src_pixels; |
79 | |
80 | out_pixel->a = le16_to_cpu(pixels[3]); |
81 | out_pixel->r = le16_to_cpu(pixels[2]); |
82 | out_pixel->g = le16_to_cpu(pixels[1]); |
83 | out_pixel->b = le16_to_cpu(pixels[0]); |
84 | } |
85 | |
86 | static void XRGB16161616_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel) |
87 | { |
88 | u16 *pixels = (u16 *)src_pixels; |
89 | |
90 | out_pixel->a = (u16)0xffff; |
91 | out_pixel->r = le16_to_cpu(pixels[2]); |
92 | out_pixel->g = le16_to_cpu(pixels[1]); |
93 | out_pixel->b = le16_to_cpu(pixels[0]); |
94 | } |
95 | |
96 | static void RGB565_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel) |
97 | { |
98 | u16 *pixels = (u16 *)src_pixels; |
99 | |
100 | s64 fp_rb_ratio = drm_fixp_div(a: drm_int2fixp(a: 65535), b: drm_int2fixp(a: 31)); |
101 | s64 fp_g_ratio = drm_fixp_div(a: drm_int2fixp(a: 65535), b: drm_int2fixp(a: 63)); |
102 | |
103 | u16 rgb_565 = le16_to_cpu(*pixels); |
104 | s64 fp_r = drm_int2fixp(a: (rgb_565 >> 11) & 0x1f); |
105 | s64 fp_g = drm_int2fixp(a: (rgb_565 >> 5) & 0x3f); |
106 | s64 fp_b = drm_int2fixp(a: rgb_565 & 0x1f); |
107 | |
108 | out_pixel->a = (u16)0xffff; |
109 | out_pixel->r = drm_fixp2int_round(a: drm_fixp_mul(a: fp_r, b: fp_rb_ratio)); |
110 | out_pixel->g = drm_fixp2int_round(a: drm_fixp_mul(a: fp_g, b: fp_g_ratio)); |
111 | out_pixel->b = drm_fixp2int_round(a: drm_fixp_mul(a: fp_b, b: fp_rb_ratio)); |
112 | } |
113 | |
114 | /** |
115 | * vkms_compose_row - compose a single row of a plane |
116 | * @stage_buffer: output line with the composed pixels |
117 | * @plane: state of the plane that is being composed |
118 | * @y: y coordinate of the row |
119 | * |
120 | * This function composes a single row of a plane. It gets the source pixels |
121 | * through the y coordinate (see get_packed_src_addr()) and goes linearly |
122 | * through the source pixel, reading the pixels and converting it to |
123 | * ARGB16161616 (see the pixel_read() callback). For rotate-90 and rotate-270, |
124 | * the source pixels are not traversed linearly. The source pixels are queried |
125 | * on each iteration in order to traverse the pixels vertically. |
126 | */ |
127 | void vkms_compose_row(struct line_buffer *stage_buffer, struct vkms_plane_state *plane, int y) |
128 | { |
129 | struct pixel_argb_u16 *out_pixels = stage_buffer->pixels; |
130 | struct vkms_frame_info *frame_info = plane->frame_info; |
131 | u8 *src_pixels = get_packed_src_addr(frame_info, y); |
132 | int limit = min_t(size_t, drm_rect_width(&frame_info->dst), stage_buffer->n_pixels); |
133 | |
134 | for (size_t x = 0; x < limit; x++, src_pixels += frame_info->cpp) { |
135 | int x_pos = get_x_position(frame_info, limit, x); |
136 | |
137 | if (drm_rotation_90_or_270(rotation: frame_info->rotation)) |
138 | src_pixels = get_packed_src_addr(frame_info, y: x + frame_info->rotated.y1) |
139 | + frame_info->cpp * y; |
140 | |
141 | plane->pixel_read(src_pixels, &out_pixels[x_pos]); |
142 | } |
143 | } |
144 | |
145 | /* |
146 | * The following functions take an line of argb_u16 pixels from the |
147 | * src_buffer, convert them to a specific format, and store them in the |
148 | * destination. |
149 | * |
150 | * They are used in the `compose_active_planes` to convert and store a line |
151 | * from the src_buffer to the writeback buffer. |
152 | */ |
153 | static void argb_u16_to_ARGB8888(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel) |
154 | { |
155 | /* |
156 | * This sequence below is important because the format's byte order is |
157 | * in little-endian. In the case of the ARGB8888 the memory is |
158 | * organized this way: |
159 | * |
160 | * | Addr | = blue channel |
161 | * | Addr + 1 | = green channel |
162 | * | Addr + 2 | = Red channel |
163 | * | Addr + 3 | = Alpha channel |
164 | */ |
165 | dst_pixels[3] = DIV_ROUND_CLOSEST(in_pixel->a, 257); |
166 | dst_pixels[2] = DIV_ROUND_CLOSEST(in_pixel->r, 257); |
167 | dst_pixels[1] = DIV_ROUND_CLOSEST(in_pixel->g, 257); |
168 | dst_pixels[0] = DIV_ROUND_CLOSEST(in_pixel->b, 257); |
169 | } |
170 | |
171 | static void argb_u16_to_XRGB8888(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel) |
172 | { |
173 | dst_pixels[3] = 0xff; |
174 | dst_pixels[2] = DIV_ROUND_CLOSEST(in_pixel->r, 257); |
175 | dst_pixels[1] = DIV_ROUND_CLOSEST(in_pixel->g, 257); |
176 | dst_pixels[0] = DIV_ROUND_CLOSEST(in_pixel->b, 257); |
177 | } |
178 | |
179 | static void argb_u16_to_ARGB16161616(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel) |
180 | { |
181 | u16 *pixels = (u16 *)dst_pixels; |
182 | |
183 | pixels[3] = cpu_to_le16(in_pixel->a); |
184 | pixels[2] = cpu_to_le16(in_pixel->r); |
185 | pixels[1] = cpu_to_le16(in_pixel->g); |
186 | pixels[0] = cpu_to_le16(in_pixel->b); |
187 | } |
188 | |
189 | static void argb_u16_to_XRGB16161616(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel) |
190 | { |
191 | u16 *pixels = (u16 *)dst_pixels; |
192 | |
193 | pixels[3] = 0xffff; |
194 | pixels[2] = cpu_to_le16(in_pixel->r); |
195 | pixels[1] = cpu_to_le16(in_pixel->g); |
196 | pixels[0] = cpu_to_le16(in_pixel->b); |
197 | } |
198 | |
199 | static void argb_u16_to_RGB565(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel) |
200 | { |
201 | u16 *pixels = (u16 *)dst_pixels; |
202 | |
203 | s64 fp_rb_ratio = drm_fixp_div(a: drm_int2fixp(a: 65535), b: drm_int2fixp(a: 31)); |
204 | s64 fp_g_ratio = drm_fixp_div(a: drm_int2fixp(a: 65535), b: drm_int2fixp(a: 63)); |
205 | |
206 | s64 fp_r = drm_int2fixp(a: in_pixel->r); |
207 | s64 fp_g = drm_int2fixp(a: in_pixel->g); |
208 | s64 fp_b = drm_int2fixp(a: in_pixel->b); |
209 | |
210 | u16 r = drm_fixp2int(a: drm_fixp_div(a: fp_r, b: fp_rb_ratio)); |
211 | u16 g = drm_fixp2int(a: drm_fixp_div(a: fp_g, b: fp_g_ratio)); |
212 | u16 b = drm_fixp2int(a: drm_fixp_div(a: fp_b, b: fp_rb_ratio)); |
213 | |
214 | *pixels = cpu_to_le16(r << 11 | g << 5 | b); |
215 | } |
216 | |
217 | void vkms_writeback_row(struct vkms_writeback_job *wb, |
218 | const struct line_buffer *src_buffer, int y) |
219 | { |
220 | struct vkms_frame_info *frame_info = &wb->wb_frame_info; |
221 | int x_dst = frame_info->dst.x1; |
222 | u8 *dst_pixels = packed_pixels_addr(frame_info, x: x_dst, y); |
223 | struct pixel_argb_u16 *in_pixels = src_buffer->pixels; |
224 | int x_limit = min_t(size_t, drm_rect_width(&frame_info->dst), src_buffer->n_pixels); |
225 | |
226 | for (size_t x = 0; x < x_limit; x++, dst_pixels += frame_info->cpp) |
227 | wb->pixel_write(dst_pixels, &in_pixels[x]); |
228 | } |
229 | |
230 | void *get_pixel_conversion_function(u32 format) |
231 | { |
232 | switch (format) { |
233 | case DRM_FORMAT_ARGB8888: |
234 | return &ARGB8888_to_argb_u16; |
235 | case DRM_FORMAT_XRGB8888: |
236 | return &XRGB8888_to_argb_u16; |
237 | case DRM_FORMAT_ARGB16161616: |
238 | return &ARGB16161616_to_argb_u16; |
239 | case DRM_FORMAT_XRGB16161616: |
240 | return &XRGB16161616_to_argb_u16; |
241 | case DRM_FORMAT_RGB565: |
242 | return &RGB565_to_argb_u16; |
243 | default: |
244 | return NULL; |
245 | } |
246 | } |
247 | |
248 | void *get_pixel_write_function(u32 format) |
249 | { |
250 | switch (format) { |
251 | case DRM_FORMAT_ARGB8888: |
252 | return &argb_u16_to_ARGB8888; |
253 | case DRM_FORMAT_XRGB8888: |
254 | return &argb_u16_to_XRGB8888; |
255 | case DRM_FORMAT_ARGB16161616: |
256 | return &argb_u16_to_ARGB16161616; |
257 | case DRM_FORMAT_XRGB16161616: |
258 | return &argb_u16_to_XRGB16161616; |
259 | case DRM_FORMAT_RGB565: |
260 | return &argb_u16_to_RGB565; |
261 | default: |
262 | return NULL; |
263 | } |
264 | } |
265 | |