1 | /* |
2 | * Copyright (c) 2016 Laurent Pinchart <laurent.pinchart@ideasonboard.com> |
3 | * |
4 | * Permission to use, copy, modify, distribute, and sell this software and its |
5 | * documentation for any purpose is hereby granted without fee, provided that |
6 | * the above copyright notice appear in all copies and that both that copyright |
7 | * notice and this permission notice appear in supporting documentation, and |
8 | * that the name of the copyright holders not be used in advertising or |
9 | * publicity pertaining to distribution of the software without specific, |
10 | * written prior permission. The copyright holders make no representations |
11 | * about the suitability of this software for any purpose. It is provided "as |
12 | * is" without express or implied warranty. |
13 | * |
14 | * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, |
15 | * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO |
16 | * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR |
17 | * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, |
18 | * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
19 | * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE |
20 | * OF THIS SOFTWARE. |
21 | */ |
22 | #ifndef __DRM_FOURCC_H__ |
23 | #define __DRM_FOURCC_H__ |
24 | |
25 | #include <linux/math.h> |
26 | #include <linux/types.h> |
27 | #include <uapi/drm/drm_fourcc.h> |
28 | |
29 | /** |
30 | * DRM_FORMAT_MAX_PLANES - maximum number of planes a DRM format can have |
31 | */ |
32 | #define DRM_FORMAT_MAX_PLANES 4u |
33 | |
34 | /* |
35 | * DRM formats are little endian. Define host endian variants for the |
36 | * most common formats here, to reduce the #ifdefs needed in drivers. |
37 | * |
38 | * Note that the DRM_FORMAT_BIG_ENDIAN flag should only be used in |
39 | * case the format can't be specified otherwise, so we don't end up |
40 | * with two values describing the same format. |
41 | */ |
42 | #ifdef __BIG_ENDIAN |
43 | # define DRM_FORMAT_HOST_XRGB1555 (DRM_FORMAT_XRGB1555 | \ |
44 | DRM_FORMAT_BIG_ENDIAN) |
45 | # define DRM_FORMAT_HOST_RGB565 (DRM_FORMAT_RGB565 | \ |
46 | DRM_FORMAT_BIG_ENDIAN) |
47 | # define DRM_FORMAT_HOST_XRGB8888 DRM_FORMAT_BGRX8888 |
48 | # define DRM_FORMAT_HOST_ARGB8888 DRM_FORMAT_BGRA8888 |
49 | #else |
50 | # define DRM_FORMAT_HOST_XRGB1555 DRM_FORMAT_XRGB1555 |
51 | # define DRM_FORMAT_HOST_RGB565 DRM_FORMAT_RGB565 |
52 | # define DRM_FORMAT_HOST_XRGB8888 DRM_FORMAT_XRGB8888 |
53 | # define DRM_FORMAT_HOST_ARGB8888 DRM_FORMAT_ARGB8888 |
54 | #endif |
55 | |
56 | struct drm_device; |
57 | struct drm_mode_fb_cmd2; |
58 | |
59 | /** |
60 | * struct drm_format_info - information about a DRM format |
61 | */ |
62 | struct drm_format_info { |
63 | /** @format: 4CC format identifier (DRM_FORMAT_*) */ |
64 | u32 format; |
65 | |
66 | /** |
67 | * @depth: |
68 | * |
69 | * Color depth (number of bits per pixel excluding padding bits), |
70 | * valid for a subset of RGB formats only. This is a legacy field, do |
71 | * not use in new code and set to 0 for new formats. |
72 | */ |
73 | u8 depth; |
74 | |
75 | /** @num_planes: Number of color planes (1 to 3) */ |
76 | u8 num_planes; |
77 | |
78 | union { |
79 | /** |
80 | * @cpp: |
81 | * |
82 | * Number of bytes per pixel (per plane), this is aliased with |
83 | * @char_per_block. It is deprecated in favour of using the |
84 | * triplet @char_per_block, @block_w, @block_h for better |
85 | * describing the pixel format. |
86 | */ |
87 | u8 cpp[DRM_FORMAT_MAX_PLANES]; |
88 | |
89 | /** |
90 | * @char_per_block: |
91 | * |
92 | * Number of bytes per block (per plane), where blocks are |
93 | * defined as a rectangle of pixels which are stored next to |
94 | * each other in a byte aligned memory region. Together with |
95 | * @block_w and @block_h this is used to properly describe tiles |
96 | * in tiled formats or to describe groups of pixels in packed |
97 | * formats for which the memory needed for a single pixel is not |
98 | * byte aligned. |
99 | * |
100 | * @cpp has been kept for historical reasons because there are |
101 | * a lot of places in drivers where it's used. In drm core for |
102 | * generic code paths the preferred way is to use |
103 | * @char_per_block, drm_format_info_block_width() and |
104 | * drm_format_info_block_height() which allows handling both |
105 | * block and non-block formats in the same way. |
106 | * |
107 | * For formats that are intended to be used only with non-linear |
108 | * modifiers both @cpp and @char_per_block must be 0 in the |
109 | * generic format table. Drivers could supply accurate |
110 | * information from their drm_mode_config.get_format_info hook |
111 | * if they want the core to be validating the pitch. |
112 | */ |
113 | u8 char_per_block[DRM_FORMAT_MAX_PLANES]; |
114 | }; |
115 | |
116 | /** |
117 | * @block_w: |
118 | * |
119 | * Block width in pixels, this is intended to be accessed through |
120 | * drm_format_info_block_width() |
121 | */ |
122 | u8 block_w[DRM_FORMAT_MAX_PLANES]; |
123 | |
124 | /** |
125 | * @block_h: |
126 | * |
127 | * Block height in pixels, this is intended to be accessed through |
128 | * drm_format_info_block_height() |
129 | */ |
130 | u8 block_h[DRM_FORMAT_MAX_PLANES]; |
131 | |
132 | /** @hsub: Horizontal chroma subsampling factor */ |
133 | u8 hsub; |
134 | /** @vsub: Vertical chroma subsampling factor */ |
135 | u8 vsub; |
136 | |
137 | /** @has_alpha: Does the format embeds an alpha component? */ |
138 | bool has_alpha; |
139 | |
140 | /** @is_yuv: Is it a YUV format? */ |
141 | bool is_yuv; |
142 | |
143 | /** @is_color_indexed: Is it a color-indexed format? */ |
144 | bool is_color_indexed; |
145 | }; |
146 | |
147 | /** |
148 | * drm_format_info_is_yuv_packed - check that the format info matches a YUV |
149 | * format with data laid in a single plane |
150 | * @info: format info |
151 | * |
152 | * Returns: |
153 | * A boolean indicating whether the format info matches a packed YUV format. |
154 | */ |
155 | static inline bool |
156 | drm_format_info_is_yuv_packed(const struct drm_format_info *info) |
157 | { |
158 | return info->is_yuv && info->num_planes == 1; |
159 | } |
160 | |
161 | /** |
162 | * drm_format_info_is_yuv_semiplanar - check that the format info matches a YUV |
163 | * format with data laid in two planes (luminance and chrominance) |
164 | * @info: format info |
165 | * |
166 | * Returns: |
167 | * A boolean indicating whether the format info matches a semiplanar YUV format. |
168 | */ |
169 | static inline bool |
170 | drm_format_info_is_yuv_semiplanar(const struct drm_format_info *info) |
171 | { |
172 | return info->is_yuv && info->num_planes == 2; |
173 | } |
174 | |
175 | /** |
176 | * drm_format_info_is_yuv_planar - check that the format info matches a YUV |
177 | * format with data laid in three planes (one for each YUV component) |
178 | * @info: format info |
179 | * |
180 | * Returns: |
181 | * A boolean indicating whether the format info matches a planar YUV format. |
182 | */ |
183 | static inline bool |
184 | drm_format_info_is_yuv_planar(const struct drm_format_info *info) |
185 | { |
186 | return info->is_yuv && info->num_planes == 3; |
187 | } |
188 | |
189 | /** |
190 | * drm_format_info_is_yuv_sampling_410 - check that the format info matches a |
191 | * YUV format with 4:1:0 sub-sampling |
192 | * @info: format info |
193 | * |
194 | * Returns: |
195 | * A boolean indicating whether the format info matches a YUV format with 4:1:0 |
196 | * sub-sampling. |
197 | */ |
198 | static inline bool |
199 | drm_format_info_is_yuv_sampling_410(const struct drm_format_info *info) |
200 | { |
201 | return info->is_yuv && info->hsub == 4 && info->vsub == 4; |
202 | } |
203 | |
204 | /** |
205 | * drm_format_info_is_yuv_sampling_411 - check that the format info matches a |
206 | * YUV format with 4:1:1 sub-sampling |
207 | * @info: format info |
208 | * |
209 | * Returns: |
210 | * A boolean indicating whether the format info matches a YUV format with 4:1:1 |
211 | * sub-sampling. |
212 | */ |
213 | static inline bool |
214 | drm_format_info_is_yuv_sampling_411(const struct drm_format_info *info) |
215 | { |
216 | return info->is_yuv && info->hsub == 4 && info->vsub == 1; |
217 | } |
218 | |
219 | /** |
220 | * drm_format_info_is_yuv_sampling_420 - check that the format info matches a |
221 | * YUV format with 4:2:0 sub-sampling |
222 | * @info: format info |
223 | * |
224 | * Returns: |
225 | * A boolean indicating whether the format info matches a YUV format with 4:2:0 |
226 | * sub-sampling. |
227 | */ |
228 | static inline bool |
229 | drm_format_info_is_yuv_sampling_420(const struct drm_format_info *info) |
230 | { |
231 | return info->is_yuv && info->hsub == 2 && info->vsub == 2; |
232 | } |
233 | |
234 | /** |
235 | * drm_format_info_is_yuv_sampling_422 - check that the format info matches a |
236 | * YUV format with 4:2:2 sub-sampling |
237 | * @info: format info |
238 | * |
239 | * Returns: |
240 | * A boolean indicating whether the format info matches a YUV format with 4:2:2 |
241 | * sub-sampling. |
242 | */ |
243 | static inline bool |
244 | drm_format_info_is_yuv_sampling_422(const struct drm_format_info *info) |
245 | { |
246 | return info->is_yuv && info->hsub == 2 && info->vsub == 1; |
247 | } |
248 | |
249 | /** |
250 | * drm_format_info_is_yuv_sampling_444 - check that the format info matches a |
251 | * YUV format with 4:4:4 sub-sampling |
252 | * @info: format info |
253 | * |
254 | * Returns: |
255 | * A boolean indicating whether the format info matches a YUV format with 4:4:4 |
256 | * sub-sampling. |
257 | */ |
258 | static inline bool |
259 | drm_format_info_is_yuv_sampling_444(const struct drm_format_info *info) |
260 | { |
261 | return info->is_yuv && info->hsub == 1 && info->vsub == 1; |
262 | } |
263 | |
264 | /** |
265 | * drm_format_info_plane_width - width of the plane given the first plane |
266 | * @info: pixel format info |
267 | * @width: width of the first plane |
268 | * @plane: plane index |
269 | * |
270 | * Returns: |
271 | * The width of @plane, given that the width of the first plane is @width. |
272 | */ |
273 | static inline |
274 | int drm_format_info_plane_width(const struct drm_format_info *info, int width, |
275 | int plane) |
276 | { |
277 | if (!info || plane >= info->num_planes) |
278 | return 0; |
279 | |
280 | if (plane == 0) |
281 | return width; |
282 | |
283 | return DIV_ROUND_UP(width, info->hsub); |
284 | } |
285 | |
286 | /** |
287 | * drm_format_info_plane_height - height of the plane given the first plane |
288 | * @info: pixel format info |
289 | * @height: height of the first plane |
290 | * @plane: plane index |
291 | * |
292 | * Returns: |
293 | * The height of @plane, given that the height of the first plane is @height. |
294 | */ |
295 | static inline |
296 | int drm_format_info_plane_height(const struct drm_format_info *info, int height, |
297 | int plane) |
298 | { |
299 | if (!info || plane >= info->num_planes) |
300 | return 0; |
301 | |
302 | if (plane == 0) |
303 | return height; |
304 | |
305 | return DIV_ROUND_UP(height, info->vsub); |
306 | } |
307 | |
308 | const struct drm_format_info *__drm_format_info(u32 format); |
309 | const struct drm_format_info *drm_format_info(u32 format); |
310 | const struct drm_format_info * |
311 | drm_get_format_info(struct drm_device *dev, |
312 | const struct drm_mode_fb_cmd2 *mode_cmd); |
313 | uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth); |
314 | uint32_t drm_driver_legacy_fb_format(struct drm_device *dev, |
315 | uint32_t bpp, uint32_t depth); |
316 | unsigned int drm_format_info_block_width(const struct drm_format_info *info, |
317 | int plane); |
318 | unsigned int drm_format_info_block_height(const struct drm_format_info *info, |
319 | int plane); |
320 | unsigned int drm_format_info_bpp(const struct drm_format_info *info, int plane); |
321 | uint64_t drm_format_info_min_pitch(const struct drm_format_info *info, |
322 | int plane, unsigned int buffer_width); |
323 | |
324 | #endif /* __DRM_FOURCC_H__ */ |
325 | |