1 | /* |
2 | * This work is licensed under the terms of the GNU GPL, version 2 or later. |
3 | * See the COPYING file in the top-level directory. |
4 | */ |
5 | |
6 | #include "qemu/osdep.h" |
7 | #include "ui/console.h" |
8 | #include "standard-headers/drm/drm_fourcc.h" |
9 | |
10 | PixelFormat qemu_pixelformat_from_pixman(pixman_format_code_t format) |
11 | { |
12 | PixelFormat pf; |
13 | uint8_t bpp; |
14 | |
15 | bpp = pf.bits_per_pixel = PIXMAN_FORMAT_BPP(format); |
16 | pf.bytes_per_pixel = PIXMAN_FORMAT_BPP(format) / 8; |
17 | pf.depth = PIXMAN_FORMAT_DEPTH(format); |
18 | |
19 | pf.abits = PIXMAN_FORMAT_A(format); |
20 | pf.rbits = PIXMAN_FORMAT_R(format); |
21 | pf.gbits = PIXMAN_FORMAT_G(format); |
22 | pf.bbits = PIXMAN_FORMAT_B(format); |
23 | |
24 | switch (PIXMAN_FORMAT_TYPE(format)) { |
25 | case PIXMAN_TYPE_ARGB: |
26 | pf.ashift = pf.bbits + pf.gbits + pf.rbits; |
27 | pf.rshift = pf.bbits + pf.gbits; |
28 | pf.gshift = pf.bbits; |
29 | pf.bshift = 0; |
30 | break; |
31 | case PIXMAN_TYPE_ABGR: |
32 | pf.ashift = pf.rbits + pf.gbits + pf.bbits; |
33 | pf.bshift = pf.rbits + pf.gbits; |
34 | pf.gshift = pf.rbits; |
35 | pf.rshift = 0; |
36 | break; |
37 | case PIXMAN_TYPE_BGRA: |
38 | pf.bshift = bpp - pf.bbits; |
39 | pf.gshift = bpp - (pf.bbits + pf.gbits); |
40 | pf.rshift = bpp - (pf.bbits + pf.gbits + pf.rbits); |
41 | pf.ashift = 0; |
42 | break; |
43 | case PIXMAN_TYPE_RGBA: |
44 | pf.rshift = bpp - pf.rbits; |
45 | pf.gshift = bpp - (pf.rbits + pf.gbits); |
46 | pf.bshift = bpp - (pf.rbits + pf.gbits + pf.bbits); |
47 | pf.ashift = 0; |
48 | break; |
49 | default: |
50 | g_assert_not_reached(); |
51 | break; |
52 | } |
53 | |
54 | pf.amax = (1 << pf.abits) - 1; |
55 | pf.rmax = (1 << pf.rbits) - 1; |
56 | pf.gmax = (1 << pf.gbits) - 1; |
57 | pf.bmax = (1 << pf.bbits) - 1; |
58 | pf.amask = pf.amax << pf.ashift; |
59 | pf.rmask = pf.rmax << pf.rshift; |
60 | pf.gmask = pf.gmax << pf.gshift; |
61 | pf.bmask = pf.bmax << pf.bshift; |
62 | |
63 | return pf; |
64 | } |
65 | |
66 | pixman_format_code_t qemu_default_pixman_format(int bpp, bool native_endian) |
67 | { |
68 | if (native_endian) { |
69 | switch (bpp) { |
70 | case 15: |
71 | return PIXMAN_x1r5g5b5; |
72 | case 16: |
73 | return PIXMAN_r5g6b5; |
74 | case 24: |
75 | return PIXMAN_r8g8b8; |
76 | case 32: |
77 | return PIXMAN_x8r8g8b8; |
78 | } |
79 | } else { |
80 | switch (bpp) { |
81 | case 24: |
82 | return PIXMAN_b8g8r8; |
83 | case 32: |
84 | return PIXMAN_b8g8r8x8; |
85 | break; |
86 | } |
87 | } |
88 | return 0; |
89 | } |
90 | |
91 | /* Note: drm is little endian, pixman is native endian */ |
92 | pixman_format_code_t qemu_drm_format_to_pixman(uint32_t drm_format) |
93 | { |
94 | static const struct { |
95 | uint32_t drm_format; |
96 | pixman_format_code_t pixman; |
97 | } map[] = { |
98 | { DRM_FORMAT_RGB888, PIXMAN_LE_r8g8b8 }, |
99 | { DRM_FORMAT_ARGB8888, PIXMAN_LE_a8r8g8b8 }, |
100 | { DRM_FORMAT_XRGB8888, PIXMAN_LE_x8r8g8b8 } |
101 | }; |
102 | int i; |
103 | |
104 | for (i = 0; i < ARRAY_SIZE(map); i++) { |
105 | if (drm_format == map[i].drm_format) { |
106 | return map[i].pixman; |
107 | } |
108 | } |
109 | return 0; |
110 | } |
111 | |
112 | int qemu_pixman_get_type(int rshift, int gshift, int bshift) |
113 | { |
114 | int type = PIXMAN_TYPE_OTHER; |
115 | |
116 | if (rshift > gshift && gshift > bshift) { |
117 | if (bshift == 0) { |
118 | type = PIXMAN_TYPE_ARGB; |
119 | } else { |
120 | type = PIXMAN_TYPE_RGBA; |
121 | } |
122 | } else if (rshift < gshift && gshift < bshift) { |
123 | if (rshift == 0) { |
124 | type = PIXMAN_TYPE_ABGR; |
125 | } else { |
126 | type = PIXMAN_TYPE_BGRA; |
127 | } |
128 | } |
129 | return type; |
130 | } |
131 | |
132 | pixman_format_code_t qemu_pixman_get_format(PixelFormat *pf) |
133 | { |
134 | pixman_format_code_t format; |
135 | int type; |
136 | |
137 | type = qemu_pixman_get_type(pf->rshift, pf->gshift, pf->bshift); |
138 | format = PIXMAN_FORMAT(pf->bits_per_pixel, type, |
139 | pf->abits, pf->rbits, pf->gbits, pf->bbits); |
140 | if (!pixman_format_supported_source(format)) { |
141 | return 0; |
142 | } |
143 | return format; |
144 | } |
145 | |
146 | /* |
147 | * Return true for known-good pixman conversions. |
148 | * |
149 | * UIs using pixman for format conversion can hook this into |
150 | * DisplayChangeListenerOps->dpy_gfx_check_format |
151 | */ |
152 | bool qemu_pixman_check_format(DisplayChangeListener *dcl, |
153 | pixman_format_code_t format) |
154 | { |
155 | switch (format) { |
156 | /* 32 bpp */ |
157 | case PIXMAN_x8r8g8b8: |
158 | case PIXMAN_a8r8g8b8: |
159 | case PIXMAN_b8g8r8x8: |
160 | case PIXMAN_b8g8r8a8: |
161 | /* 24 bpp */ |
162 | case PIXMAN_r8g8b8: |
163 | case PIXMAN_b8g8r8: |
164 | /* 16 bpp */ |
165 | case PIXMAN_x1r5g5b5: |
166 | case PIXMAN_r5g6b5: |
167 | return true; |
168 | default: |
169 | return false; |
170 | } |
171 | } |
172 | |
173 | pixman_image_t *qemu_pixman_linebuf_create(pixman_format_code_t format, |
174 | int width) |
175 | { |
176 | pixman_image_t *image = pixman_image_create_bits(format, width, 1, NULL, 0); |
177 | assert(image != NULL); |
178 | return image; |
179 | } |
180 | |
181 | /* fill linebuf from framebuffer */ |
182 | void qemu_pixman_linebuf_fill(pixman_image_t *linebuf, pixman_image_t *fb, |
183 | int width, int x, int y) |
184 | { |
185 | pixman_image_composite(PIXMAN_OP_SRC, fb, NULL, linebuf, |
186 | x, y, 0, 0, 0, 0, width, 1); |
187 | } |
188 | |
189 | /* copy linebuf to framebuffer */ |
190 | void qemu_pixman_linebuf_copy(pixman_image_t *fb, int width, int x, int y, |
191 | pixman_image_t *linebuf) |
192 | { |
193 | pixman_image_composite(PIXMAN_OP_SRC, linebuf, NULL, fb, |
194 | 0, 0, 0, 0, x, y, width, 1); |
195 | } |
196 | |
197 | pixman_image_t *qemu_pixman_mirror_create(pixman_format_code_t format, |
198 | pixman_image_t *image) |
199 | { |
200 | return pixman_image_create_bits(format, |
201 | pixman_image_get_width(image), |
202 | pixman_image_get_height(image), |
203 | NULL, |
204 | pixman_image_get_stride(image)); |
205 | } |
206 | |
207 | void qemu_pixman_image_unref(pixman_image_t *image) |
208 | { |
209 | if (image == NULL) { |
210 | return; |
211 | } |
212 | pixman_image_unref(image); |
213 | } |
214 | |
215 | pixman_color_t qemu_pixman_color(PixelFormat *pf, uint32_t color) |
216 | { |
217 | pixman_color_t c; |
218 | |
219 | c.red = ((color & pf->rmask) >> pf->rshift) << (16 - pf->rbits); |
220 | c.green = ((color & pf->gmask) >> pf->gshift) << (16 - pf->gbits); |
221 | c.blue = ((color & pf->bmask) >> pf->bshift) << (16 - pf->bbits); |
222 | c.alpha = ((color & pf->amask) >> pf->ashift) << (16 - pf->abits); |
223 | return c; |
224 | } |
225 | |
226 | pixman_image_t *qemu_pixman_glyph_from_vgafont(int height, const uint8_t *font, |
227 | unsigned int ch) |
228 | { |
229 | pixman_image_t *glyph; |
230 | uint8_t *data; |
231 | bool bit; |
232 | int x, y; |
233 | |
234 | glyph = pixman_image_create_bits(PIXMAN_a8, 8, height, |
235 | NULL, 0); |
236 | data = (uint8_t *)pixman_image_get_data(glyph); |
237 | |
238 | font += height * ch; |
239 | for (y = 0; y < height; y++, font++) { |
240 | for (x = 0; x < 8; x++, data++) { |
241 | bit = (*font) & (1 << (7-x)); |
242 | *data = bit ? 0xff : 0x00; |
243 | } |
244 | } |
245 | return glyph; |
246 | } |
247 | |
248 | void qemu_pixman_glyph_render(pixman_image_t *glyph, |
249 | pixman_image_t *surface, |
250 | pixman_color_t *fgcol, |
251 | pixman_color_t *bgcol, |
252 | int x, int y, int cw, int ch) |
253 | { |
254 | pixman_image_t *ifg = pixman_image_create_solid_fill(fgcol); |
255 | pixman_image_t *ibg = pixman_image_create_solid_fill(bgcol); |
256 | |
257 | pixman_image_composite(PIXMAN_OP_SRC, ibg, NULL, surface, |
258 | 0, 0, 0, 0, |
259 | cw * x, ch * y, |
260 | cw, ch); |
261 | pixman_image_composite(PIXMAN_OP_OVER, ifg, glyph, surface, |
262 | 0, 0, 0, 0, |
263 | cw * x, ch * y, |
264 | cw, ch); |
265 | pixman_image_unref(ifg); |
266 | pixman_image_unref(ibg); |
267 | } |
268 | |