Loading...
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
56struct drm_device;
57struct drm_mode_fb_cmd2;
58
59/**
60 * struct drm_format_info - information about a DRM format
61 */
62struct 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 */
155static inline bool
156drm_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 */
169static inline bool
170drm_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 */
183static inline bool
184drm_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 */
198static inline bool
199drm_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 */
213static inline bool
214drm_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 */
228static inline bool
229drm_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 */
243static inline bool
244drm_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 */
258static inline bool
259drm_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 */
273static inline
274int 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 */
295static inline
296int 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
308const struct drm_format_info *__drm_format_info(u32 format);
309const struct drm_format_info *drm_format_info(u32 format);
310const struct drm_format_info *
311drm_get_format_info(struct drm_device *dev,
312 const struct drm_mode_fb_cmd2 *mode_cmd);
313uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth);
314uint32_t drm_driver_legacy_fb_format(struct drm_device *dev,
315 uint32_t bpp, uint32_t depth);
316uint32_t drm_driver_color_mode_format(struct drm_device *dev, unsigned int color_mode);
317unsigned int drm_format_info_block_width(const struct drm_format_info *info,
318 int plane);
319unsigned int drm_format_info_block_height(const struct drm_format_info *info,
320 int plane);
321unsigned int drm_format_info_bpp(const struct drm_format_info *info, int plane);
322uint64_t drm_format_info_min_pitch(const struct drm_format_info *info,
323 int plane, unsigned int buffer_width);
324
325#endif /* __DRM_FOURCC_H__ */
1/*
2 * Copyright 2011 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
22 */
23
24#ifndef DRM_FOURCC_H
25#define DRM_FOURCC_H
26
27#include <linux/types.h>
28
29#define fourcc_code(a, b, c, d) ((__u32)(a) | ((__u32)(b) << 8) | \
30 ((__u32)(c) << 16) | ((__u32)(d) << 24))
31
32#define DRM_FORMAT_BIG_ENDIAN (1<<31) /* format is big endian instead of little endian */
33
34/* color index */
35#define DRM_FORMAT_C8 fourcc_code('C', '8', ' ', ' ') /* [7:0] C */
36
37/* 8 bpp RGB */
38#define DRM_FORMAT_RGB332 fourcc_code('R', 'G', 'B', '8') /* [7:0] R:G:B 3:3:2 */
39#define DRM_FORMAT_BGR233 fourcc_code('B', 'G', 'R', '8') /* [7:0] B:G:R 2:3:3 */
40
41/* 16 bpp RGB */
42#define DRM_FORMAT_XRGB4444 fourcc_code('X', 'R', '1', '2') /* [15:0] x:R:G:B 4:4:4:4 little endian */
43#define DRM_FORMAT_XBGR4444 fourcc_code('X', 'B', '1', '2') /* [15:0] x:B:G:R 4:4:4:4 little endian */
44#define DRM_FORMAT_RGBX4444 fourcc_code('R', 'X', '1', '2') /* [15:0] R:G:B:x 4:4:4:4 little endian */
45#define DRM_FORMAT_BGRX4444 fourcc_code('B', 'X', '1', '2') /* [15:0] B:G:R:x 4:4:4:4 little endian */
46
47#define DRM_FORMAT_ARGB4444 fourcc_code('A', 'R', '1', '2') /* [15:0] A:R:G:B 4:4:4:4 little endian */
48#define DRM_FORMAT_ABGR4444 fourcc_code('A', 'B', '1', '2') /* [15:0] A:B:G:R 4:4:4:4 little endian */
49#define DRM_FORMAT_RGBA4444 fourcc_code('R', 'A', '1', '2') /* [15:0] R:G:B:A 4:4:4:4 little endian */
50#define DRM_FORMAT_BGRA4444 fourcc_code('B', 'A', '1', '2') /* [15:0] B:G:R:A 4:4:4:4 little endian */
51
52#define DRM_FORMAT_XRGB1555 fourcc_code('X', 'R', '1', '5') /* [15:0] x:R:G:B 1:5:5:5 little endian */
53#define DRM_FORMAT_XBGR1555 fourcc_code('X', 'B', '1', '5') /* [15:0] x:B:G:R 1:5:5:5 little endian */
54#define DRM_FORMAT_RGBX5551 fourcc_code('R', 'X', '1', '5') /* [15:0] R:G:B:x 5:5:5:1 little endian */
55#define DRM_FORMAT_BGRX5551 fourcc_code('B', 'X', '1', '5') /* [15:0] B:G:R:x 5:5:5:1 little endian */
56
57#define DRM_FORMAT_ARGB1555 fourcc_code('A', 'R', '1', '5') /* [15:0] A:R:G:B 1:5:5:5 little endian */
58#define DRM_FORMAT_ABGR1555 fourcc_code('A', 'B', '1', '5') /* [15:0] A:B:G:R 1:5:5:5 little endian */
59#define DRM_FORMAT_RGBA5551 fourcc_code('R', 'A', '1', '5') /* [15:0] R:G:B:A 5:5:5:1 little endian */
60#define DRM_FORMAT_BGRA5551 fourcc_code('B', 'A', '1', '5') /* [15:0] B:G:R:A 5:5:5:1 little endian */
61
62#define DRM_FORMAT_RGB565 fourcc_code('R', 'G', '1', '6') /* [15:0] R:G:B 5:6:5 little endian */
63#define DRM_FORMAT_BGR565 fourcc_code('B', 'G', '1', '6') /* [15:0] B:G:R 5:6:5 little endian */
64
65/* 24 bpp RGB */
66#define DRM_FORMAT_RGB888 fourcc_code('R', 'G', '2', '4') /* [23:0] R:G:B little endian */
67#define DRM_FORMAT_BGR888 fourcc_code('B', 'G', '2', '4') /* [23:0] B:G:R little endian */
68
69/* 32 bpp RGB */
70#define DRM_FORMAT_XRGB8888 fourcc_code('X', 'R', '2', '4') /* [31:0] x:R:G:B 8:8:8:8 little endian */
71#define DRM_FORMAT_XBGR8888 fourcc_code('X', 'B', '2', '4') /* [31:0] x:B:G:R 8:8:8:8 little endian */
72#define DRM_FORMAT_RGBX8888 fourcc_code('R', 'X', '2', '4') /* [31:0] R:G:B:x 8:8:8:8 little endian */
73#define DRM_FORMAT_BGRX8888 fourcc_code('B', 'X', '2', '4') /* [31:0] B:G:R:x 8:8:8:8 little endian */
74
75#define DRM_FORMAT_ARGB8888 fourcc_code('A', 'R', '2', '4') /* [31:0] A:R:G:B 8:8:8:8 little endian */
76#define DRM_FORMAT_ABGR8888 fourcc_code('A', 'B', '2', '4') /* [31:0] A:B:G:R 8:8:8:8 little endian */
77#define DRM_FORMAT_RGBA8888 fourcc_code('R', 'A', '2', '4') /* [31:0] R:G:B:A 8:8:8:8 little endian */
78#define DRM_FORMAT_BGRA8888 fourcc_code('B', 'A', '2', '4') /* [31:0] B:G:R:A 8:8:8:8 little endian */
79
80#define DRM_FORMAT_XRGB2101010 fourcc_code('X', 'R', '3', '0') /* [31:0] x:R:G:B 2:10:10:10 little endian */
81#define DRM_FORMAT_XBGR2101010 fourcc_code('X', 'B', '3', '0') /* [31:0] x:B:G:R 2:10:10:10 little endian */
82#define DRM_FORMAT_RGBX1010102 fourcc_code('R', 'X', '3', '0') /* [31:0] R:G:B:x 10:10:10:2 little endian */
83#define DRM_FORMAT_BGRX1010102 fourcc_code('B', 'X', '3', '0') /* [31:0] B:G:R:x 10:10:10:2 little endian */
84
85#define DRM_FORMAT_ARGB2101010 fourcc_code('A', 'R', '3', '0') /* [31:0] A:R:G:B 2:10:10:10 little endian */
86#define DRM_FORMAT_ABGR2101010 fourcc_code('A', 'B', '3', '0') /* [31:0] A:B:G:R 2:10:10:10 little endian */
87#define DRM_FORMAT_RGBA1010102 fourcc_code('R', 'A', '3', '0') /* [31:0] R:G:B:A 10:10:10:2 little endian */
88#define DRM_FORMAT_BGRA1010102 fourcc_code('B', 'A', '3', '0') /* [31:0] B:G:R:A 10:10:10:2 little endian */
89
90/* packed YCbCr */
91#define DRM_FORMAT_YUYV fourcc_code('Y', 'U', 'Y', 'V') /* [31:0] Cr0:Y1:Cb0:Y0 8:8:8:8 little endian */
92#define DRM_FORMAT_YVYU fourcc_code('Y', 'V', 'Y', 'U') /* [31:0] Cb0:Y1:Cr0:Y0 8:8:8:8 little endian */
93#define DRM_FORMAT_UYVY fourcc_code('U', 'Y', 'V', 'Y') /* [31:0] Y1:Cr0:Y0:Cb0 8:8:8:8 little endian */
94#define DRM_FORMAT_VYUY fourcc_code('V', 'Y', 'U', 'Y') /* [31:0] Y1:Cb0:Y0:Cr0 8:8:8:8 little endian */
95
96#define DRM_FORMAT_AYUV fourcc_code('A', 'Y', 'U', 'V') /* [31:0] A:Y:Cb:Cr 8:8:8:8 little endian */
97
98/*
99 * 2 plane YCbCr
100 * index 0 = Y plane, [7:0] Y
101 * index 1 = Cr:Cb plane, [15:0] Cr:Cb little endian
102 * or
103 * index 1 = Cb:Cr plane, [15:0] Cb:Cr little endian
104 */
105#define DRM_FORMAT_NV12 fourcc_code('N', 'V', '1', '2') /* 2x2 subsampled Cr:Cb plane */
106#define DRM_FORMAT_NV21 fourcc_code('N', 'V', '2', '1') /* 2x2 subsampled Cb:Cr plane */
107#define DRM_FORMAT_NV16 fourcc_code('N', 'V', '1', '6') /* 2x1 subsampled Cr:Cb plane */
108#define DRM_FORMAT_NV61 fourcc_code('N', 'V', '6', '1') /* 2x1 subsampled Cb:Cr plane */
109
110/* 2 non contiguous plane YCbCr */
111#define DRM_FORMAT_NV12M fourcc_code('N', 'M', '1', '2') /* 2x2 subsampled Cr:Cb plane */
112#define DRM_FORMAT_NV12MT fourcc_code('T', 'M', '1', '2') /* 2x2 subsampled Cr:Cb plane 64x32 macroblocks */
113
114/*
115 * 3 plane YCbCr
116 * index 0: Y plane, [7:0] Y
117 * index 1: Cb plane, [7:0] Cb
118 * index 2: Cr plane, [7:0] Cr
119 * or
120 * index 1: Cr plane, [7:0] Cr
121 * index 2: Cb plane, [7:0] Cb
122 */
123#define DRM_FORMAT_YUV410 fourcc_code('Y', 'U', 'V', '9') /* 4x4 subsampled Cb (1) and Cr (2) planes */
124#define DRM_FORMAT_YVU410 fourcc_code('Y', 'V', 'U', '9') /* 4x4 subsampled Cr (1) and Cb (2) planes */
125#define DRM_FORMAT_YUV411 fourcc_code('Y', 'U', '1', '1') /* 4x1 subsampled Cb (1) and Cr (2) planes */
126#define DRM_FORMAT_YVU411 fourcc_code('Y', 'V', '1', '1') /* 4x1 subsampled Cr (1) and Cb (2) planes */
127#define DRM_FORMAT_YUV420 fourcc_code('Y', 'U', '1', '2') /* 2x2 subsampled Cb (1) and Cr (2) planes */
128#define DRM_FORMAT_YVU420 fourcc_code('Y', 'V', '1', '2') /* 2x2 subsampled Cr (1) and Cb (2) planes */
129#define DRM_FORMAT_YUV422 fourcc_code('Y', 'U', '1', '6') /* 2x1 subsampled Cb (1) and Cr (2) planes */
130#define DRM_FORMAT_YVU422 fourcc_code('Y', 'V', '1', '6') /* 2x1 subsampled Cr (1) and Cb (2) planes */
131#define DRM_FORMAT_YUV444 fourcc_code('Y', 'U', '2', '4') /* non-subsampled Cb (1) and Cr (2) planes */
132#define DRM_FORMAT_YVU444 fourcc_code('Y', 'V', '2', '4') /* non-subsampled Cr (1) and Cb (2) planes */
133
134/* 3 non contiguous plane YCbCr */
135#define DRM_FORMAT_YUV420M fourcc_code('Y', 'M', '1', '2') /* 2x2 subsampled Cb (1) and Cr (2) planes */
136
137#endif /* DRM_FOURCC_H */