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