]>
Commit | Line | Data |
---|---|---|
ae4df11a LP |
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/types.h> | |
26 | #include <uapi/drm/drm_fourcc.h> | |
27 | ||
ec2fae25 GH |
28 | /* |
29 | * DRM formats are little endian. Define host endian variants for the | |
30 | * most common formats here, to reduce the #ifdefs needed in drivers. | |
31 | * | |
32 | * Note that the DRM_FORMAT_BIG_ENDIAN flag should only be used in | |
33 | * case the format can't be specified otherwise, so we don't end up | |
34 | * with two values describing the same format. | |
35 | */ | |
36 | #ifdef __BIG_ENDIAN | |
37 | # define DRM_FORMAT_HOST_XRGB1555 (DRM_FORMAT_XRGB1555 | \ | |
38 | DRM_FORMAT_BIG_ENDIAN) | |
39 | # define DRM_FORMAT_HOST_RGB565 (DRM_FORMAT_RGB565 | \ | |
40 | DRM_FORMAT_BIG_ENDIAN) | |
41 | # define DRM_FORMAT_HOST_XRGB8888 DRM_FORMAT_BGRX8888 | |
42 | # define DRM_FORMAT_HOST_ARGB8888 DRM_FORMAT_BGRA8888 | |
43 | #else | |
44 | # define DRM_FORMAT_HOST_XRGB1555 DRM_FORMAT_XRGB1555 | |
45 | # define DRM_FORMAT_HOST_RGB565 DRM_FORMAT_RGB565 | |
46 | # define DRM_FORMAT_HOST_XRGB8888 DRM_FORMAT_XRGB8888 | |
47 | # define DRM_FORMAT_HOST_ARGB8888 DRM_FORMAT_ARGB8888 | |
48 | #endif | |
49 | ||
6a0f9ebf VS |
50 | struct drm_device; |
51 | struct drm_mode_fb_cmd2; | |
52 | ||
84770cc2 LP |
53 | /** |
54 | * struct drm_format_info - information about a DRM format | |
84770cc2 LP |
55 | */ |
56 | struct drm_format_info { | |
9c71a668 | 57 | /** @format: 4CC format identifier (DRM_FORMAT_*) */ |
84770cc2 | 58 | u32 format; |
9c71a668 AG |
59 | |
60 | /** | |
61 | * @depth: | |
62 | * | |
63 | * Color depth (number of bits per pixel excluding padding bits), | |
64 | * valid for a subset of RGB formats only. This is a legacy field, do | |
65 | * not use in new code and set to 0 for new formats. | |
66 | */ | |
84770cc2 | 67 | u8 depth; |
9c71a668 AG |
68 | |
69 | /** @num_planes: Number of color planes (1 to 3) */ | |
84770cc2 | 70 | u8 num_planes; |
9c71a668 | 71 | |
042bf753 AG |
72 | union { |
73 | /** | |
74 | * @cpp: | |
75 | * | |
76 | * Number of bytes per pixel (per plane), this is aliased with | |
77 | * @char_per_block. It is deprecated in favour of using the | |
78 | * triplet @char_per_block, @block_w, @block_h for better | |
79 | * describing the pixel format. | |
80 | */ | |
a7007efa | 81 | u8 cpp[4]; |
042bf753 AG |
82 | |
83 | /** | |
84 | * @char_per_block: | |
85 | * | |
86 | * Number of bytes per block (per plane), where blocks are | |
87 | * defined as a rectangle of pixels which are stored next to | |
88 | * each other in a byte aligned memory region. Together with | |
89 | * @block_w and @block_h this is used to properly describe tiles | |
90 | * in tiled formats or to describe groups of pixels in packed | |
91 | * formats for which the memory needed for a single pixel is not | |
92 | * byte aligned. | |
93 | * | |
94 | * @cpp has been kept for historical reasons because there are | |
95 | * a lot of places in drivers where it's used. In drm core for | |
96 | * generic code paths the preferred way is to use | |
97 | * @char_per_block, drm_format_info_block_width() and | |
98 | * drm_format_info_block_height() which allows handling both | |
99 | * block and non-block formats in the same way. | |
100 | * | |
101 | * For formats that are intended to be used only with non-linear | |
102 | * modifiers both @cpp and @char_per_block must be 0 in the | |
103 | * generic format table. Drivers could supply accurate | |
104 | * information from their drm_mode_config.get_format_info hook | |
105 | * if they want the core to be validating the pitch. | |
106 | */ | |
a7007efa | 107 | u8 char_per_block[4]; |
042bf753 AG |
108 | }; |
109 | ||
110 | /** | |
111 | * @block_w: | |
112 | * | |
113 | * Block width in pixels, this is intended to be accessed through | |
114 | * drm_format_info_block_width() | |
115 | */ | |
a7007efa | 116 | u8 block_w[4]; |
042bf753 AG |
117 | |
118 | /** | |
119 | * @block_h: | |
120 | * | |
121 | * Block height in pixels, this is intended to be accessed through | |
122 | * drm_format_info_block_height() | |
123 | */ | |
a7007efa | 124 | u8 block_h[4]; |
9c71a668 AG |
125 | |
126 | /** @hsub: Horizontal chroma subsampling factor */ | |
84770cc2 | 127 | u8 hsub; |
9c71a668 | 128 | /** @vsub: Vertical chroma subsampling factor */ |
84770cc2 | 129 | u8 vsub; |
9c71a668 AG |
130 | |
131 | /** @has_alpha: Does the format embeds an alpha component? */ | |
4cc4e1b4 | 132 | bool has_alpha; |
9c71a668 AG |
133 | |
134 | /** @is_yuv: Is it a YUV format? */ | |
ce2d5461 | 135 | bool is_yuv; |
84770cc2 LP |
136 | }; |
137 | ||
b3c11ac2 EE |
138 | /** |
139 | * struct drm_format_name_buf - name of a DRM format | |
140 | * @str: string buffer containing the format name | |
141 | */ | |
142 | struct drm_format_name_buf { | |
143 | char str[32]; | |
144 | }; | |
145 | ||
41c8c210 PK |
146 | /** |
147 | * drm_format_info_is_yuv_packed - check that the format info matches a YUV | |
148 | * format with data laid in a single plane | |
149 | * @info: format info | |
150 | * | |
151 | * Returns: | |
152 | * A boolean indicating whether the format info matches a packed YUV format. | |
153 | */ | |
154 | static inline bool | |
155 | drm_format_info_is_yuv_packed(const struct drm_format_info *info) | |
156 | { | |
157 | return info->is_yuv && info->num_planes == 1; | |
158 | } | |
159 | ||
160 | /** | |
161 | * drm_format_info_is_yuv_semiplanar - check that the format info matches a YUV | |
162 | * format with data laid in two planes (luminance and chrominance) | |
163 | * @info: format info | |
164 | * | |
165 | * Returns: | |
166 | * A boolean indicating whether the format info matches a semiplanar YUV format. | |
167 | */ | |
168 | static inline bool | |
169 | drm_format_info_is_yuv_semiplanar(const struct drm_format_info *info) | |
170 | { | |
171 | return info->is_yuv && info->num_planes == 2; | |
172 | } | |
173 | ||
174 | /** | |
175 | * drm_format_info_is_yuv_planar - check that the format info matches a YUV | |
176 | * format with data laid in three planes (one for each YUV component) | |
177 | * @info: format info | |
178 | * | |
179 | * Returns: | |
180 | * A boolean indicating whether the format info matches a planar YUV format. | |
181 | */ | |
182 | static inline bool | |
183 | drm_format_info_is_yuv_planar(const struct drm_format_info *info) | |
184 | { | |
185 | return info->is_yuv && info->num_planes == 3; | |
186 | } | |
187 | ||
a211e56e PK |
188 | /** |
189 | * drm_format_info_is_yuv_sampling_410 - check that the format info matches a | |
190 | * YUV format with 4:1:0 sub-sampling | |
191 | * @info: format info | |
192 | * | |
193 | * Returns: | |
194 | * A boolean indicating whether the format info matches a YUV format with 4:1:0 | |
195 | * sub-sampling. | |
196 | */ | |
197 | static inline bool | |
198 | drm_format_info_is_yuv_sampling_410(const struct drm_format_info *info) | |
199 | { | |
200 | return info->is_yuv && info->hsub == 4 && info->vsub == 4; | |
201 | } | |
202 | ||
203 | /** | |
204 | * drm_format_info_is_yuv_sampling_411 - check that the format info matches a | |
205 | * YUV format with 4:1:1 sub-sampling | |
206 | * @info: format info | |
207 | * | |
208 | * Returns: | |
209 | * A boolean indicating whether the format info matches a YUV format with 4:1:1 | |
210 | * sub-sampling. | |
211 | */ | |
212 | static inline bool | |
213 | drm_format_info_is_yuv_sampling_411(const struct drm_format_info *info) | |
214 | { | |
215 | return info->is_yuv && info->hsub == 4 && info->vsub == 1; | |
216 | } | |
217 | ||
218 | /** | |
219 | * drm_format_info_is_yuv_sampling_420 - check that the format info matches a | |
220 | * YUV format with 4:2:0 sub-sampling | |
221 | * @info: format info | |
222 | * | |
223 | * Returns: | |
224 | * A boolean indicating whether the format info matches a YUV format with 4:2:0 | |
225 | * sub-sampling. | |
226 | */ | |
227 | static inline bool | |
228 | drm_format_info_is_yuv_sampling_420(const struct drm_format_info *info) | |
229 | { | |
230 | return info->is_yuv && info->hsub == 2 && info->vsub == 2; | |
231 | } | |
232 | ||
233 | /** | |
234 | * drm_format_info_is_yuv_sampling_422 - check that the format info matches a | |
235 | * YUV format with 4:2:2 sub-sampling | |
236 | * @info: format info | |
237 | * | |
238 | * Returns: | |
239 | * A boolean indicating whether the format info matches a YUV format with 4:2:2 | |
240 | * sub-sampling. | |
241 | */ | |
242 | static inline bool | |
243 | drm_format_info_is_yuv_sampling_422(const struct drm_format_info *info) | |
244 | { | |
245 | return info->is_yuv && info->hsub == 2 && info->vsub == 1; | |
246 | } | |
247 | ||
248 | /** | |
249 | * drm_format_info_is_yuv_sampling_444 - check that the format info matches a | |
250 | * YUV format with 4:4:4 sub-sampling | |
251 | * @info: format info | |
252 | * | |
253 | * Returns: | |
254 | * A boolean indicating whether the format info matches a YUV format with 4:4:4 | |
255 | * sub-sampling. | |
256 | */ | |
257 | static inline bool | |
258 | drm_format_info_is_yuv_sampling_444(const struct drm_format_info *info) | |
259 | { | |
260 | return info->is_yuv && info->hsub == 1 && info->vsub == 1; | |
261 | } | |
262 | ||
bf39607c MR |
263 | /** |
264 | * drm_format_info_plane_width - width of the plane given the first plane | |
7793a108 | 265 | * @info: pixel format info |
bf39607c MR |
266 | * @width: width of the first plane |
267 | * @plane: plane index | |
268 | * | |
269 | * Returns: | |
270 | * The width of @plane, given that the width of the first plane is @width. | |
271 | */ | |
272 | static inline | |
273 | int drm_format_info_plane_width(const struct drm_format_info *info, int width, | |
274 | int plane) | |
275 | { | |
276 | if (!info || plane >= info->num_planes) | |
277 | return 0; | |
278 | ||
279 | if (plane == 0) | |
280 | return width; | |
281 | ||
282 | return width / info->hsub; | |
283 | } | |
284 | ||
285 | /** | |
286 | * drm_format_info_plane_height - height of the plane given the first plane | |
7793a108 | 287 | * @info: pixel format info |
bf39607c MR |
288 | * @height: height of the first plane |
289 | * @plane: plane index | |
290 | * | |
291 | * Returns: | |
292 | * The height of @plane, given that the height of the first plane is @height. | |
293 | */ | |
294 | static inline | |
295 | int drm_format_info_plane_height(const struct drm_format_info *info, int height, | |
296 | int plane) | |
297 | { | |
298 | if (!info || plane >= info->num_planes) | |
299 | return 0; | |
300 | ||
301 | if (plane == 0) | |
302 | return height; | |
303 | ||
304 | return height / info->vsub; | |
305 | } | |
306 | ||
333d2da5 | 307 | const struct drm_format_info *__drm_format_info(u32 format); |
84770cc2 | 308 | const struct drm_format_info *drm_format_info(u32 format); |
6a0f9ebf VS |
309 | const struct drm_format_info * |
310 | drm_get_format_info(struct drm_device *dev, | |
311 | const struct drm_mode_fb_cmd2 *mode_cmd); | |
ec5e3047 | 312 | uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth); |
059b5eb5 GH |
313 | uint32_t drm_driver_legacy_fb_format(struct drm_device *dev, |
314 | uint32_t bpp, uint32_t depth); | |
042bf753 AG |
315 | unsigned int drm_format_info_block_width(const struct drm_format_info *info, |
316 | int plane); | |
317 | unsigned int drm_format_info_block_height(const struct drm_format_info *info, | |
318 | int plane); | |
319 | uint64_t drm_format_info_min_pitch(const struct drm_format_info *info, | |
320 | int plane, unsigned int buffer_width); | |
b3c11ac2 | 321 | const char *drm_get_format_name(uint32_t format, struct drm_format_name_buf *buf); |
ae4df11a LP |
322 | |
323 | #endif /* __DRM_FOURCC_H__ */ |