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