ui/qemu-pixman.c

   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 */