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 }; 101 102 pixman_format_code_t qemu_drm_format_to_pixman(uint32_t drm_format) 103 { 104 int i; 105 106 for (i = 0; i < ARRAY_SIZE(drm_format_pixman_map); i++) { 107 if (drm_format == drm_format_pixman_map[i].drm_format) { 108 return drm_format_pixman_map[i].pixman_format; 109 } 110 } 111 return 0; 112 } 113 114 uint32_t qemu_pixman_to_drm_format(pixman_format_code_t pixman_format) 115 { 116 int i; 117 118 for (i = 0; i < ARRAY_SIZE(drm_format_pixman_map); i++) { 119 if (pixman_format == drm_format_pixman_map[i].pixman_format) { 120 return drm_format_pixman_map[i].drm_format; 121 } 122 } 123 return 0; 124 } 125 126 int qemu_pixman_get_type(int rshift, int gshift, int bshift) 127 { 128 int type = PIXMAN_TYPE_OTHER; 129 130 if (rshift > gshift && gshift > bshift) { 131 if (bshift == 0) { 132 type = PIXMAN_TYPE_ARGB; 133 } else { 134 type = PIXMAN_TYPE_RGBA; 135 } 136 } else if (rshift < gshift && gshift < bshift) { 137 if (rshift == 0) { 138 type = PIXMAN_TYPE_ABGR; 139 } else { 140 type = PIXMAN_TYPE_BGRA; 141 } 142 } 143 return type; 144 } 145 146 pixman_format_code_t qemu_pixman_get_format(PixelFormat *pf) 147 { 148 pixman_format_code_t format; 149 int type; 150 151 type = qemu_pixman_get_type(pf->rshift, pf->gshift, pf->bshift); 152 format = PIXMAN_FORMAT(pf->bits_per_pixel, type, 153 pf->abits, pf->rbits, pf->gbits, pf->bbits); 154 if (!pixman_format_supported_source(format)) { 155 return 0; 156 } 157 return format; 158 } 159 160 /* 161 * Return true for known-good pixman conversions. 162 * 163 * UIs using pixman for format conversion can hook this into 164 * DisplayChangeListenerOps->dpy_gfx_check_format 165 */ 166 bool qemu_pixman_check_format(DisplayChangeListener *dcl, 167 pixman_format_code_t format) 168 { 169 switch (format) { 170 /* 32 bpp */ 171 case PIXMAN_x8r8g8b8: 172 case PIXMAN_a8r8g8b8: 173 case PIXMAN_b8g8r8x8: 174 case PIXMAN_b8g8r8a8: 175 /* 24 bpp */ 176 case PIXMAN_r8g8b8: 177 case PIXMAN_b8g8r8: 178 /* 16 bpp */ 179 case PIXMAN_x1r5g5b5: 180 case PIXMAN_r5g6b5: 181 return true; 182 default: 183 return false; 184 } 185 } 186 187 pixman_image_t *qemu_pixman_linebuf_create(pixman_format_code_t format, 188 int width) 189 { 190 pixman_image_t *image = pixman_image_create_bits(format, width, 1, NULL, 0); 191 assert(image != NULL); 192 return image; 193 } 194 195 /* fill linebuf from framebuffer */ 196 void qemu_pixman_linebuf_fill(pixman_image_t *linebuf, pixman_image_t *fb, 197 int width, int x, int y) 198 { 199 pixman_image_composite(PIXMAN_OP_SRC, fb, NULL, linebuf, 200 x, y, 0, 0, 0, 0, width, 1); 201 } 202 203 /* copy linebuf to framebuffer */ 204 void qemu_pixman_linebuf_copy(pixman_image_t *fb, int width, int x, int y, 205 pixman_image_t *linebuf) 206 { 207 pixman_image_composite(PIXMAN_OP_SRC, linebuf, NULL, fb, 208 0, 0, 0, 0, x, y, width, 1); 209 } 210 211 pixman_image_t *qemu_pixman_mirror_create(pixman_format_code_t format, 212 pixman_image_t *image) 213 { 214 return pixman_image_create_bits(format, 215 pixman_image_get_width(image), 216 pixman_image_get_height(image), 217 NULL, 218 pixman_image_get_stride(image)); 219 } 220 221 void qemu_pixman_image_unref(pixman_image_t *image) 222 { 223 if (image == NULL) { 224 return; 225 } 226 pixman_image_unref(image); 227 } 228 229 pixman_color_t qemu_pixman_color(PixelFormat *pf, uint32_t color) 230 { 231 pixman_color_t c; 232 233 c.red = ((color & pf->rmask) >> pf->rshift) << (16 - pf->rbits); 234 c.green = ((color & pf->gmask) >> pf->gshift) << (16 - pf->gbits); 235 c.blue = ((color & pf->bmask) >> pf->bshift) << (16 - pf->bbits); 236 c.alpha = ((color & pf->amask) >> pf->ashift) << (16 - pf->abits); 237 return c; 238 } 239 240 pixman_image_t *qemu_pixman_glyph_from_vgafont(int height, const uint8_t *font, 241 unsigned int ch) 242 { 243 pixman_image_t *glyph; 244 uint8_t *data; 245 bool bit; 246 int x, y; 247 248 glyph = pixman_image_create_bits(PIXMAN_a8, 8, height, 249 NULL, 0); 250 data = (uint8_t *)pixman_image_get_data(glyph); 251 252 font += height * ch; 253 for (y = 0; y < height; y++, font++) { 254 for (x = 0; x < 8; x++, data++) { 255 bit = (*font) & (1 << (7-x)); 256 *data = bit ? 0xff : 0x00; 257 } 258 } 259 return glyph; 260 } 261 262 void qemu_pixman_glyph_render(pixman_image_t *glyph, 263 pixman_image_t *surface, 264 pixman_color_t *fgcol, 265 pixman_color_t *bgcol, 266 int x, int y, int cw, int ch) 267 { 268 pixman_image_t *ifg = pixman_image_create_solid_fill(fgcol); 269 pixman_image_t *ibg = pixman_image_create_solid_fill(bgcol); 270 271 pixman_image_composite(PIXMAN_OP_SRC, ibg, NULL, surface, 272 0, 0, 0, 0, 273 cw * x, ch * y, 274 cw, ch); 275 pixman_image_composite(PIXMAN_OP_OVER, ifg, glyph, surface, 276 0, 0, 0, 0, 277 cw * x, ch * y, 278 cw, ch); 279 pixman_image_unref(ifg); 280 pixman_image_unref(ibg); 281 } 282