1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
/*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*/
#include "qemu-common.h"
#include "ui/console.h"
int qemu_pixman_get_type(int rshift, int gshift, int bshift)
{
int type = PIXMAN_TYPE_OTHER;
if (rshift > gshift && gshift > bshift) {
if (bshift == 0) {
type = PIXMAN_TYPE_ARGB;
} else {
#if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0, 21, 8)
type = PIXMAN_TYPE_RGBA;
#endif
}
} else if (rshift < gshift && gshift < bshift) {
if (rshift == 0) {
type = PIXMAN_TYPE_ABGR;
} else {
#if PIXMAN_VERSION >= PIXMAN_VERSION_ENCODE(0, 16, 0)
type = PIXMAN_TYPE_BGRA;
#endif
}
}
return type;
}
pixman_format_code_t qemu_pixman_get_format(PixelFormat *pf)
{
pixman_format_code_t format;
int type;
type = qemu_pixman_get_type(pf->rshift, pf->gshift, pf->bshift);
format = PIXMAN_FORMAT(pf->bits_per_pixel, type,
pf->abits, pf->rbits, pf->gbits, pf->bbits);
if (!pixman_format_supported_source(format)) {
return 0;
}
return format;
}
pixman_image_t *qemu_pixman_linebuf_create(pixman_format_code_t format,
int width)
{
pixman_image_t *image = pixman_image_create_bits(format, width, 1, NULL, 0);
assert(image != NULL);
return image;
}
void qemu_pixman_linebuf_fill(pixman_image_t *linebuf, pixman_image_t *fb,
int width, int x, int y)
{
pixman_image_composite(PIXMAN_OP_SRC, fb, NULL, linebuf,
x, y, 0, 0, 0, 0, width, 1);
}
pixman_image_t *qemu_pixman_mirror_create(pixman_format_code_t format,
pixman_image_t *image)
{
pixman_image_t *mirror;
mirror = pixman_image_create_bits(format,
pixman_image_get_width(image),
pixman_image_get_height(image),
NULL,
pixman_image_get_stride(image));
return mirror;
}
void qemu_pixman_image_unref(pixman_image_t *image)
{
if (image == NULL) {
return;
}
pixman_image_unref(image);
}
pixman_color_t qemu_pixman_color(PixelFormat *pf, uint32_t color)
{
pixman_color_t c;
c.red = ((color & pf->rmask) >> pf->rshift) << (16 - pf->rbits);
c.green = ((color & pf->gmask) >> pf->gshift) << (16 - pf->gbits);
c.blue = ((color & pf->bmask) >> pf->bshift) << (16 - pf->bbits);
c.alpha = ((color & pf->amask) >> pf->ashift) << (16 - pf->abits);
return c;
}
pixman_image_t *qemu_pixman_glyph_from_vgafont(int height, const uint8_t *font,
unsigned int ch)
{
pixman_image_t *glyph;
uint8_t *data;
bool bit;
int x, y;
glyph = pixman_image_create_bits(PIXMAN_a8, 8, height,
NULL, 0);
data = (uint8_t *)pixman_image_get_data(glyph);
font += height * ch;
for (y = 0; y < height; y++, font++) {
for (x = 0; x < 8; x++, data++) {
bit = (*font) & (1 << (7-x));
*data = bit ? 0xff : 0x00;
}
}
return glyph;
}
void qemu_pixman_glyph_render(pixman_image_t *glyph,
pixman_image_t *surface,
pixman_color_t *fgcol,
pixman_color_t *bgcol,
int x, int y, int cw, int ch)
{
pixman_image_t *ifg = pixman_image_create_solid_fill(fgcol);
pixman_image_t *ibg = pixman_image_create_solid_fill(bgcol);
pixman_image_composite(PIXMAN_OP_SRC, ibg, NULL, surface,
0, 0, 0, 0,
cw * x, ch * y,
cw, ch);
pixman_image_composite(PIXMAN_OP_OVER, ifg, glyph, surface,
0, 0, 0, 0,
cw * x, ch * y,
cw, ch);
pixman_image_unref(ifg);
pixman_image_unref(ibg);
}
|
