ia64/xen-unstable

view tools/ioemu/hw/vga_template.h @ 6946:e703abaf6e3d

Add behaviour to the remove methods to remove the transaction's path itself. This allows us to write Remove(path) to remove the specified path rather than having to slice the path ourselves.
author emellor@ewan
date Sun Sep 18 14:42:13 2005 +0100 (2005-09-18)
parents 8e5fc5fe636c
children 08a11694b109
line source
1 /*
2 * QEMU VGA Emulator templates
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
25 #if DEPTH == 8
26 #define BPP 1
27 #define PIXEL_TYPE uint8_t
28 #elif DEPTH == 15 || DEPTH == 16
29 #define BPP 2
30 #define PIXEL_TYPE uint16_t
31 #elif DEPTH == 32
32 #define BPP 4
33 #define PIXEL_TYPE uint32_t
34 #else
35 #error unsupport depth
36 #endif
38 #if DEPTH != 15
40 static inline void glue(vga_draw_glyph_line_, DEPTH)(uint8_t *d,
41 uint32_t font_data,
42 uint32_t xorcol,
43 uint32_t bgcol)
44 {
45 #if BPP == 1
46 ((uint32_t *)d)[0] = (dmask16[(font_data >> 4)] & xorcol) ^ bgcol;
47 ((uint32_t *)d)[1] = (dmask16[(font_data >> 0) & 0xf] & xorcol) ^ bgcol;
48 #elif BPP == 2
49 ((uint32_t *)d)[0] = (dmask4[(font_data >> 6)] & xorcol) ^ bgcol;
50 ((uint32_t *)d)[1] = (dmask4[(font_data >> 4) & 3] & xorcol) ^ bgcol;
51 ((uint32_t *)d)[2] = (dmask4[(font_data >> 2) & 3] & xorcol) ^ bgcol;
52 ((uint32_t *)d)[3] = (dmask4[(font_data >> 0) & 3] & xorcol) ^ bgcol;
53 #else
54 ((uint32_t *)d)[0] = (-((font_data >> 7)) & xorcol) ^ bgcol;
55 ((uint32_t *)d)[1] = (-((font_data >> 6) & 1) & xorcol) ^ bgcol;
56 ((uint32_t *)d)[2] = (-((font_data >> 5) & 1) & xorcol) ^ bgcol;
57 ((uint32_t *)d)[3] = (-((font_data >> 4) & 1) & xorcol) ^ bgcol;
58 ((uint32_t *)d)[4] = (-((font_data >> 3) & 1) & xorcol) ^ bgcol;
59 ((uint32_t *)d)[5] = (-((font_data >> 2) & 1) & xorcol) ^ bgcol;
60 ((uint32_t *)d)[6] = (-((font_data >> 1) & 1) & xorcol) ^ bgcol;
61 ((uint32_t *)d)[7] = (-((font_data >> 0) & 1) & xorcol) ^ bgcol;
62 #endif
63 }
65 static void glue(vga_draw_glyph8_, DEPTH)(uint8_t *d, int linesize,
66 const uint8_t *font_ptr, int h,
67 uint32_t fgcol, uint32_t bgcol)
68 {
69 uint32_t font_data, xorcol;
71 xorcol = bgcol ^ fgcol;
72 do {
73 font_data = font_ptr[0];
74 glue(vga_draw_glyph_line_, DEPTH)(d, font_data, xorcol, bgcol);
75 font_ptr += 4;
76 d += linesize;
77 } while (--h);
78 }
80 static void glue(vga_draw_glyph16_, DEPTH)(uint8_t *d, int linesize,
81 const uint8_t *font_ptr, int h,
82 uint32_t fgcol, uint32_t bgcol)
83 {
84 uint32_t font_data, xorcol;
86 xorcol = bgcol ^ fgcol;
87 do {
88 font_data = font_ptr[0];
89 glue(vga_draw_glyph_line_, DEPTH)(d,
90 expand4to8[font_data >> 4],
91 xorcol, bgcol);
92 glue(vga_draw_glyph_line_, DEPTH)(d + 8 * BPP,
93 expand4to8[font_data & 0x0f],
94 xorcol, bgcol);
95 font_ptr += 4;
96 d += linesize;
97 } while (--h);
98 }
100 static void glue(vga_draw_glyph9_, DEPTH)(uint8_t *d, int linesize,
101 const uint8_t *font_ptr, int h,
102 uint32_t fgcol, uint32_t bgcol, int dup9)
103 {
104 uint32_t font_data, xorcol, v;
106 xorcol = bgcol ^ fgcol;
107 do {
108 font_data = font_ptr[0];
109 #if BPP == 1
110 cpu_to_32wu((uint32_t *)d, (dmask16[(font_data >> 4)] & xorcol) ^ bgcol);
111 v = (dmask16[(font_data >> 0) & 0xf] & xorcol) ^ bgcol;
112 cpu_to_32wu(((uint32_t *)d)+1, v);
113 if (dup9)
114 ((uint8_t *)d)[8] = v >> (24 * (1 - BIG));
115 else
116 ((uint8_t *)d)[8] = bgcol;
118 #elif BPP == 2
119 cpu_to_32wu(((uint32_t *)d)+0, (dmask4[(font_data >> 6)] & xorcol) ^ bgcol);
120 cpu_to_32wu(((uint32_t *)d)+1, (dmask4[(font_data >> 4) & 3] & xorcol) ^ bgcol);
121 cpu_to_32wu(((uint32_t *)d)+2, (dmask4[(font_data >> 2) & 3] & xorcol) ^ bgcol);
122 v = (dmask4[(font_data >> 0) & 3] & xorcol) ^ bgcol;
123 cpu_to_32wu(((uint32_t *)d)+3, v);
124 if (dup9)
125 ((uint16_t *)d)[8] = v >> (16 * (1 - BIG));
126 else
127 ((uint16_t *)d)[8] = bgcol;
128 #else
129 ((uint32_t *)d)[0] = (-((font_data >> 7)) & xorcol) ^ bgcol;
130 ((uint32_t *)d)[1] = (-((font_data >> 6) & 1) & xorcol) ^ bgcol;
131 ((uint32_t *)d)[2] = (-((font_data >> 5) & 1) & xorcol) ^ bgcol;
132 ((uint32_t *)d)[3] = (-((font_data >> 4) & 1) & xorcol) ^ bgcol;
133 ((uint32_t *)d)[4] = (-((font_data >> 3) & 1) & xorcol) ^ bgcol;
134 ((uint32_t *)d)[5] = (-((font_data >> 2) & 1) & xorcol) ^ bgcol;
135 ((uint32_t *)d)[6] = (-((font_data >> 1) & 1) & xorcol) ^ bgcol;
136 v = (-((font_data >> 0) & 1) & xorcol) ^ bgcol;
137 ((uint32_t *)d)[7] = v;
138 if (dup9)
139 ((uint32_t *)d)[8] = v;
140 else
141 ((uint32_t *)d)[8] = bgcol;
142 #endif
143 font_ptr += 4;
144 d += linesize;
145 } while (--h);
146 }
148 /*
149 * 4 color mode
150 */
151 static void glue(vga_draw_line2_, DEPTH)(VGAState *s1, uint8_t *d,
152 const uint8_t *s, int width)
153 {
154 uint32_t plane_mask, *palette, data, v;
155 int x;
157 palette = s1->last_palette;
158 plane_mask = mask16[s1->ar[0x12] & 0xf];
159 width >>= 3;
160 for(x = 0; x < width; x++) {
161 data = ((uint32_t *)s)[0];
162 data &= plane_mask;
163 v = expand2[GET_PLANE(data, 0)];
164 v |= expand2[GET_PLANE(data, 2)] << 2;
165 ((PIXEL_TYPE *)d)[0] = palette[v >> 12];
166 ((PIXEL_TYPE *)d)[1] = palette[(v >> 8) & 0xf];
167 ((PIXEL_TYPE *)d)[2] = palette[(v >> 4) & 0xf];
168 ((PIXEL_TYPE *)d)[3] = palette[(v >> 0) & 0xf];
170 v = expand2[GET_PLANE(data, 1)];
171 v |= expand2[GET_PLANE(data, 3)] << 2;
172 ((PIXEL_TYPE *)d)[4] = palette[v >> 12];
173 ((PIXEL_TYPE *)d)[5] = palette[(v >> 8) & 0xf];
174 ((PIXEL_TYPE *)d)[6] = palette[(v >> 4) & 0xf];
175 ((PIXEL_TYPE *)d)[7] = palette[(v >> 0) & 0xf];
176 d += BPP * 8;
177 s += 4;
178 }
179 }
181 #if BPP == 1
182 #define PUT_PIXEL2(d, n, v) ((uint16_t *)d)[(n)] = (v)
183 #elif BPP == 2
184 #define PUT_PIXEL2(d, n, v) ((uint32_t *)d)[(n)] = (v)
185 #else
186 #define PUT_PIXEL2(d, n, v) \
187 ((uint32_t *)d)[2*(n)] = ((uint32_t *)d)[2*(n)+1] = (v)
188 #endif
190 /*
191 * 4 color mode, dup2 horizontal
192 */
193 static void glue(vga_draw_line2d2_, DEPTH)(VGAState *s1, uint8_t *d,
194 const uint8_t *s, int width)
195 {
196 uint32_t plane_mask, *palette, data, v;
197 int x;
199 palette = s1->last_palette;
200 plane_mask = mask16[s1->ar[0x12] & 0xf];
201 width >>= 3;
202 for(x = 0; x < width; x++) {
203 data = ((uint32_t *)s)[0];
204 data &= plane_mask;
205 v = expand2[GET_PLANE(data, 0)];
206 v |= expand2[GET_PLANE(data, 2)] << 2;
207 PUT_PIXEL2(d, 0, palette[v >> 12]);
208 PUT_PIXEL2(d, 1, palette[(v >> 8) & 0xf]);
209 PUT_PIXEL2(d, 2, palette[(v >> 4) & 0xf]);
210 PUT_PIXEL2(d, 3, palette[(v >> 0) & 0xf]);
212 v = expand2[GET_PLANE(data, 1)];
213 v |= expand2[GET_PLANE(data, 3)] << 2;
214 PUT_PIXEL2(d, 4, palette[v >> 12]);
215 PUT_PIXEL2(d, 5, palette[(v >> 8) & 0xf]);
216 PUT_PIXEL2(d, 6, palette[(v >> 4) & 0xf]);
217 PUT_PIXEL2(d, 7, palette[(v >> 0) & 0xf]);
218 d += BPP * 16;
219 s += 4;
220 }
221 }
223 /*
224 * 16 color mode
225 */
226 static void glue(vga_draw_line4_, DEPTH)(VGAState *s1, uint8_t *d,
227 const uint8_t *s, int width)
228 {
229 uint32_t plane_mask, data, v, *palette;
230 int x;
232 palette = s1->last_palette;
233 plane_mask = mask16[s1->ar[0x12] & 0xf];
234 width >>= 3;
235 for(x = 0; x < width; x++) {
236 data = ((uint32_t *)s)[0];
237 data &= plane_mask;
238 v = expand4[GET_PLANE(data, 0)];
239 v |= expand4[GET_PLANE(data, 1)] << 1;
240 v |= expand4[GET_PLANE(data, 2)] << 2;
241 v |= expand4[GET_PLANE(data, 3)] << 3;
242 ((PIXEL_TYPE *)d)[0] = palette[v >> 28];
243 ((PIXEL_TYPE *)d)[1] = palette[(v >> 24) & 0xf];
244 ((PIXEL_TYPE *)d)[2] = palette[(v >> 20) & 0xf];
245 ((PIXEL_TYPE *)d)[3] = palette[(v >> 16) & 0xf];
246 ((PIXEL_TYPE *)d)[4] = palette[(v >> 12) & 0xf];
247 ((PIXEL_TYPE *)d)[5] = palette[(v >> 8) & 0xf];
248 ((PIXEL_TYPE *)d)[6] = palette[(v >> 4) & 0xf];
249 ((PIXEL_TYPE *)d)[7] = palette[(v >> 0) & 0xf];
250 d += BPP * 8;
251 s += 4;
252 }
253 }
255 /*
256 * 16 color mode, dup2 horizontal
257 */
258 static void glue(vga_draw_line4d2_, DEPTH)(VGAState *s1, uint8_t *d,
259 const uint8_t *s, int width)
260 {
261 uint32_t plane_mask, data, v, *palette;
262 int x;
264 palette = s1->last_palette;
265 plane_mask = mask16[s1->ar[0x12] & 0xf];
266 width >>= 3;
267 for(x = 0; x < width; x++) {
268 data = ((uint32_t *)s)[0];
269 data &= plane_mask;
270 v = expand4[GET_PLANE(data, 0)];
271 v |= expand4[GET_PLANE(data, 1)] << 1;
272 v |= expand4[GET_PLANE(data, 2)] << 2;
273 v |= expand4[GET_PLANE(data, 3)] << 3;
274 PUT_PIXEL2(d, 0, palette[v >> 28]);
275 PUT_PIXEL2(d, 1, palette[(v >> 24) & 0xf]);
276 PUT_PIXEL2(d, 2, palette[(v >> 20) & 0xf]);
277 PUT_PIXEL2(d, 3, palette[(v >> 16) & 0xf]);
278 PUT_PIXEL2(d, 4, palette[(v >> 12) & 0xf]);
279 PUT_PIXEL2(d, 5, palette[(v >> 8) & 0xf]);
280 PUT_PIXEL2(d, 6, palette[(v >> 4) & 0xf]);
281 PUT_PIXEL2(d, 7, palette[(v >> 0) & 0xf]);
282 d += BPP * 16;
283 s += 4;
284 }
285 }
287 /*
288 * 256 color mode, double pixels
289 *
290 * XXX: add plane_mask support (never used in standard VGA modes)
291 */
292 static void glue(vga_draw_line8d2_, DEPTH)(VGAState *s1, uint8_t *d,
293 const uint8_t *s, int width)
294 {
295 uint32_t *palette;
296 int x;
298 palette = s1->last_palette;
299 width >>= 3;
300 for(x = 0; x < width; x++) {
301 PUT_PIXEL2(d, 0, palette[s[0]]);
302 PUT_PIXEL2(d, 1, palette[s[1]]);
303 PUT_PIXEL2(d, 2, palette[s[2]]);
304 PUT_PIXEL2(d, 3, palette[s[3]]);
305 d += BPP * 8;
306 s += 4;
307 }
308 }
310 /*
311 * standard 256 color mode
312 *
313 * XXX: add plane_mask support (never used in standard VGA modes)
314 */
315 static void glue(vga_draw_line8_, DEPTH)(VGAState *s1, uint8_t *d,
316 const uint8_t *s, int width)
317 {
318 uint32_t *palette;
319 int x;
321 palette = s1->last_palette;
322 width >>= 3;
323 for(x = 0; x < width; x++) {
324 ((PIXEL_TYPE *)d)[0] = palette[s[0]];
325 ((PIXEL_TYPE *)d)[1] = palette[s[1]];
326 ((PIXEL_TYPE *)d)[2] = palette[s[2]];
327 ((PIXEL_TYPE *)d)[3] = palette[s[3]];
328 ((PIXEL_TYPE *)d)[4] = palette[s[4]];
329 ((PIXEL_TYPE *)d)[5] = palette[s[5]];
330 ((PIXEL_TYPE *)d)[6] = palette[s[6]];
331 ((PIXEL_TYPE *)d)[7] = palette[s[7]];
332 d += BPP * 8;
333 s += 8;
334 }
335 }
337 #endif /* DEPTH != 15 */
340 /* XXX: optimize */
342 /*
343 * 15 bit color
344 */
345 static void glue(vga_draw_line15_, DEPTH)(VGAState *s1, uint8_t *d,
346 const uint8_t *s, int width)
347 {
348 #if DEPTH == 15 && defined(WORDS_BIGENDIAN) == defined(TARGET_WORDS_BIGENDIAN)
349 memcpy(d, s, width * 2);
350 #else
351 int w;
352 uint32_t v, r, g, b;
354 w = width;
355 do {
356 v = lduw_raw((void *)s);
357 r = (v >> 7) & 0xf8;
358 g = (v >> 2) & 0xf8;
359 b = (v << 3) & 0xf8;
360 ((PIXEL_TYPE *)d)[0] = glue(rgb_to_pixel, DEPTH)(r, g, b);
361 s += 2;
362 d += BPP;
363 } while (--w != 0);
364 #endif
365 }
367 /*
368 * 16 bit color
369 */
370 static void glue(vga_draw_line16_, DEPTH)(VGAState *s1, uint8_t *d,
371 const uint8_t *s, int width)
372 {
373 #if DEPTH == 16 && defined(WORDS_BIGENDIAN) == defined(TARGET_WORDS_BIGENDIAN)
374 memcpy(d, s, width * 2);
375 #else
376 int w;
377 uint32_t v, r, g, b;
379 w = width;
380 do {
381 v = lduw_raw((void *)s);
382 r = (v >> 8) & 0xf8;
383 g = (v >> 3) & 0xfc;
384 b = (v << 3) & 0xf8;
385 ((PIXEL_TYPE *)d)[0] = glue(rgb_to_pixel, DEPTH)(r, g, b);
386 s += 2;
387 d += BPP;
388 } while (--w != 0);
389 #endif
390 }
392 /*
393 * 24 bit color
394 */
395 static void glue(vga_draw_line24_, DEPTH)(VGAState *s1, uint8_t *d,
396 const uint8_t *s, int width)
397 {
398 int w;
399 uint32_t r, g, b;
401 w = width;
402 do {
403 #if defined(TARGET_WORDS_BIGENDIAN)
404 r = s[0];
405 g = s[1];
406 b = s[2];
407 #else
408 b = s[0];
409 g = s[1];
410 r = s[2];
411 #endif
412 ((PIXEL_TYPE *)d)[0] = glue(rgb_to_pixel, DEPTH)(r, g, b);
413 s += 3;
414 d += BPP;
415 } while (--w != 0);
416 }
418 /*
419 * 32 bit color
420 */
421 static void glue(vga_draw_line32_, DEPTH)(VGAState *s1, uint8_t *d,
422 const uint8_t *s, int width)
423 {
424 #if DEPTH == 32 && defined(WORDS_BIGENDIAN) == defined(TARGET_WORDS_BIGENDIAN)
425 memcpy(d, s, width * 4);
426 #else
427 int w;
428 uint32_t r, g, b;
430 w = width;
431 do {
432 #if defined(TARGET_WORDS_BIGENDIAN)
433 r = s[1];
434 g = s[2];
435 b = s[3];
436 #else
437 b = s[0];
438 g = s[1];
439 r = s[2];
440 #endif
441 ((PIXEL_TYPE *)d)[0] = glue(rgb_to_pixel, DEPTH)(r, g, b);
442 s += 4;
443 d += BPP;
444 } while (--w != 0);
445 #endif
446 }
448 #if DEPTH != 15
449 void glue(vga_draw_cursor_line_, DEPTH)(uint8_t *d1,
450 const uint8_t *src1,
451 int poffset, int w,
452 unsigned int color0,
453 unsigned int color1,
454 unsigned int color_xor)
455 {
456 const uint8_t *plane0, *plane1;
457 int x, b0, b1;
458 uint8_t *d;
460 d = d1;
461 plane0 = src1;
462 plane1 = src1 + poffset;
463 for(x = 0; x < w; x++) {
464 b0 = (plane0[x >> 3] >> (7 - (x & 7))) & 1;
465 b1 = (plane1[x >> 3] >> (7 - (x & 7))) & 1;
466 #if DEPTH == 8
467 switch(b0 | (b1 << 1)) {
468 case 0:
469 break;
470 case 1:
471 d[0] ^= color_xor;
472 break;
473 case 2:
474 d[0] = color0;
475 break;
476 case 3:
477 d[0] = color1;
478 break;
479 }
480 #elif DEPTH == 16
481 switch(b0 | (b1 << 1)) {
482 case 0:
483 break;
484 case 1:
485 ((uint16_t *)d)[0] ^= color_xor;
486 break;
487 case 2:
488 ((uint16_t *)d)[0] = color0;
489 break;
490 case 3:
491 ((uint16_t *)d)[0] = color1;
492 break;
493 }
494 #elif DEPTH == 32
495 switch(b0 | (b1 << 1)) {
496 case 0:
497 break;
498 case 1:
499 ((uint32_t *)d)[0] ^= color_xor;
500 break;
501 case 2:
502 ((uint32_t *)d)[0] = color0;
503 break;
504 case 3:
505 ((uint32_t *)d)[0] = color1;
506 break;
507 }
508 #else
509 #error unsupported depth
510 #endif
511 d += BPP;
512 }
513 }
514 #endif
516 #undef PUT_PIXEL2
517 #undef DEPTH
518 #undef BPP
519 #undef PIXEL_TYPE