?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qemu-iotests: add backing file smaller than image test case
[qemu.git] / console.c
blob4525cc70b87bb287dd05c2a723d9a77b0612d20c
1 /*
2 * QEMU graphical console
3 *
4 * Copyright (c) 2004 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 */
24 #include "qemu-common.h"
25 #include "console.h"
26 #include "qemu-timer.h"
27
28 //#define DEBUG_CONSOLE
29 #define DEFAULT_BACKSCROLL 512
30 #define MAX_CONSOLES 12
31 #define CONSOLE_CURSOR_PERIOD 500
32
33 #define QEMU_RGBA(r, g, b, a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
34 #define QEMU_RGB(r, g, b) QEMU_RGBA(r, g, b, 0xff)
35
36 typedef struct TextAttributes {
37 uint8_t fgcol:4;
38 uint8_t bgcol:4;
39 uint8_t bold:1;
40 uint8_t uline:1;
41 uint8_t blink:1;
42 uint8_t invers:1;
43 uint8_t unvisible:1;
44 } TextAttributes;
45
46 typedef struct TextCell {
47 uint8_t ch;
48 TextAttributes t_attrib;
49 } TextCell;
50
51 #define MAX_ESC_PARAMS 3
52
53 enum TTYState {
54 TTY_STATE_NORM,
55 TTY_STATE_ESC,
56 TTY_STATE_CSI,
57 };
58
59 typedef struct QEMUFIFO {
60 uint8_t *buf;
61 int buf_size;
62 int count, wptr, rptr;
63 } QEMUFIFO;
64
65 static int qemu_fifo_write(QEMUFIFO *f, const uint8_t *buf, int len1)
66 {
67 int l, len;
68
69 l = f->buf_size - f->count;
70 if (len1 > l)
71 len1 = l;
72 len = len1;
73 while (len > 0) {
74 l = f->buf_size - f->wptr;
75 if (l > len)
76 l = len;
77 memcpy(f->buf + f->wptr, buf, l);
78 f->wptr += l;
79 if (f->wptr >= f->buf_size)
80 f->wptr = 0;
81 buf += l;
82 len -= l;
83 }
84 f->count += len1;
85 return len1;
86 }
87
88 static int qemu_fifo_read(QEMUFIFO *f, uint8_t *buf, int len1)
89 {
90 int l, len;
91
92 if (len1 > f->count)
93 len1 = f->count;
94 len = len1;
95 while (len > 0) {
96 l = f->buf_size - f->rptr;
97 if (l > len)
98 l = len;
99 memcpy(buf, f->buf + f->rptr, l);
100 f->rptr += l;
101 if (f->rptr >= f->buf_size)
102 f->rptr = 0;
103 buf += l;
104 len -= l;
105 }
106 f->count -= len1;
107 return len1;
108 }
109
110 typedef enum {
111 GRAPHIC_CONSOLE,
112 TEXT_CONSOLE,
113 TEXT_CONSOLE_FIXED_SIZE
114 } console_type_t;
115
116 /* ??? This is mis-named.
117 It is used for both text and graphical consoles. */
118 struct TextConsole {
119 int index;
120 console_type_t console_type;
121 DisplayState *ds;
122 /* Graphic console state. */
123 vga_hw_update_ptr hw_update;
124 vga_hw_invalidate_ptr hw_invalidate;
125 vga_hw_screen_dump_ptr hw_screen_dump;
126 vga_hw_text_update_ptr hw_text_update;
127 void *hw;
128
129 int g_width, g_height;
130 int width;
131 int height;
132 int total_height;
133 int backscroll_height;
134 int x, y;
135 int x_saved, y_saved;
136 int y_displayed;
137 int y_base;
138 TextAttributes t_attrib_default; /* default text attributes */
139 TextAttributes t_attrib; /* currently active text attributes */
140 TextCell *cells;
141 int text_x[2], text_y[2], cursor_invalidate;
142 int echo;
143 bool cursor_visible_phase;
144 QEMUTimer *cursor_timer;
145
146 int update_x0;
147 int update_y0;
148 int update_x1;
149 int update_y1;
150
151 enum TTYState state;
152 int esc_params[MAX_ESC_PARAMS];
153 int nb_esc_params;
154
155 CharDriverState *chr;
156 /* fifo for key pressed */
157 QEMUFIFO out_fifo;
158 uint8_t out_fifo_buf[16];
159 QEMUTimer *kbd_timer;
160 };
161
162 static DisplayState *display_state;
163 static TextConsole *active_console;
164 static TextConsole *consoles[MAX_CONSOLES];
165 static int nb_consoles = 0;
166
167 void vga_hw_update(void)
168 {
169 if (active_console && active_console->hw_update)
170 active_console->hw_update(active_console->hw);
171 }
172
173 void vga_hw_invalidate(void)
174 {
175 if (active_console && active_console->hw_invalidate)
176 active_console->hw_invalidate(active_console->hw);
177 }
178
179 void vga_hw_screen_dump(const char *filename)
180 {
181 TextConsole *previous_active_console;
182 bool cswitch;
183
184 previous_active_console = active_console;
185 cswitch = previous_active_console && previous_active_console->index != 0;
186
187 /* There is currently no way of specifying which screen we want to dump,
188 so always dump the first one. */
189 if (cswitch) {
190 console_select(0);
191 }
192 if (consoles[0] && consoles[0]->hw_screen_dump) {
193 consoles[0]->hw_screen_dump(consoles[0]->hw, filename, cswitch);
194 } else {
195 error_report("screen dump not implemented");
196 }
197
198 if (cswitch) {
199 console_select(previous_active_console->index);
200 }
201 }
202
203 void vga_hw_text_update(console_ch_t *chardata)
204 {
205 if (active_console && active_console->hw_text_update)
206 active_console->hw_text_update(active_console->hw, chardata);
207 }
208
209 /* convert a RGBA color to a color index usable in graphic primitives */
210 static unsigned int vga_get_color(DisplayState *ds, unsigned int rgba)
211 {
212 unsigned int r, g, b, color;
213
214 switch(ds_get_bits_per_pixel(ds)) {
215 #if 0
216 case 8:
217 r = (rgba >> 16) & 0xff;
218 g = (rgba >> 8) & 0xff;
219 b = (rgba) & 0xff;
220 color = (rgb_to_index[r] * 6 * 6) +
221 (rgb_to_index[g] * 6) +
222 (rgb_to_index[b]);
223 break;
224 #endif
225 case 15:
226 r = (rgba >> 16) & 0xff;
227 g = (rgba >> 8) & 0xff;
228 b = (rgba) & 0xff;
229 color = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3);
230 break;
231 case 16:
232 r = (rgba >> 16) & 0xff;
233 g = (rgba >> 8) & 0xff;
234 b = (rgba) & 0xff;
235 color = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
236 break;
237 case 32:
238 default:
239 color = rgba;
240 break;
241 }
242 return color;
243 }
244
245 static void vga_fill_rect (DisplayState *ds,
246 int posx, int posy, int width, int height, uint32_t color)
247 {
248 uint8_t *d, *d1;
249 int x, y, bpp;
250
251 bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
252 d1 = ds_get_data(ds) +
253 ds_get_linesize(ds) * posy + bpp * posx;
254 for (y = 0; y < height; y++) {
255 d = d1;
256 switch(bpp) {
257 case 1:
258 for (x = 0; x < width; x++) {
259 *((uint8_t *)d) = color;
260 d++;
261 }
262 break;
263 case 2:
264 for (x = 0; x < width; x++) {
265 *((uint16_t *)d) = color;
266 d += 2;
267 }
268 break;
269 case 4:
270 for (x = 0; x < width; x++) {
271 *((uint32_t *)d) = color;
272 d += 4;
273 }
274 break;
275 }
276 d1 += ds_get_linesize(ds);
277 }
278 }
279
280 /* copy from (xs, ys) to (xd, yd) a rectangle of size (w, h) */
281 static void vga_bitblt(DisplayState *ds, int xs, int ys, int xd, int yd, int w, int h)
282 {
283 const uint8_t *s;
284 uint8_t *d;
285 int wb, y, bpp;
286
287 bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
288 wb = w * bpp;
289 if (yd <= ys) {
290 s = ds_get_data(ds) +
291 ds_get_linesize(ds) * ys + bpp * xs;
292 d = ds_get_data(ds) +
293 ds_get_linesize(ds) * yd + bpp * xd;
294 for (y = 0; y < h; y++) {
295 memmove(d, s, wb);
296 d += ds_get_linesize(ds);
297 s += ds_get_linesize(ds);
298 }
299 } else {
300 s = ds_get_data(ds) +
301 ds_get_linesize(ds) * (ys + h - 1) + bpp * xs;
302 d = ds_get_data(ds) +
303 ds_get_linesize(ds) * (yd + h - 1) + bpp * xd;
304 for (y = 0; y < h; y++) {
305 memmove(d, s, wb);
306 d -= ds_get_linesize(ds);
307 s -= ds_get_linesize(ds);
308 }
309 }
310 }
311
312 /***********************************************************/
313 /* basic char display */
314
315 #define FONT_HEIGHT 16
316 #define FONT_WIDTH 8
317
318 #include "vgafont.h"
319
320 #define cbswap_32(__x) \
321 ((uint32_t)( \
322 (((uint32_t)(__x) & (uint32_t)0x000000ffUL) << 24) | \
323 (((uint32_t)(__x) & (uint32_t)0x0000ff00UL) << 8) | \
324 (((uint32_t)(__x) & (uint32_t)0x00ff0000UL) >> 8) | \
325 (((uint32_t)(__x) & (uint32_t)0xff000000UL) >> 24) ))
326
327 #ifdef HOST_WORDS_BIGENDIAN
328 #define PAT(x) x
329 #else
330 #define PAT(x) cbswap_32(x)
331 #endif
332
333 static const uint32_t dmask16[16] = {
334 PAT(0x00000000),
335 PAT(0x000000ff),
336 PAT(0x0000ff00),
337 PAT(0x0000ffff),
338 PAT(0x00ff0000),
339 PAT(0x00ff00ff),
340 PAT(0x00ffff00),
341 PAT(0x00ffffff),
342 PAT(0xff000000),
343 PAT(0xff0000ff),
344 PAT(0xff00ff00),
345 PAT(0xff00ffff),
346 PAT(0xffff0000),
347 PAT(0xffff00ff),
348 PAT(0xffffff00),
349 PAT(0xffffffff),
350 };
351
352 static const uint32_t dmask4[4] = {
353 PAT(0x00000000),
354 PAT(0x0000ffff),
355 PAT(0xffff0000),
356 PAT(0xffffffff),
357 };
358
359 static uint32_t color_table[2][8];
360
361 #ifndef CONFIG_CURSES
362 enum color_names {
363 COLOR_BLACK = 0,
364 COLOR_RED = 1,
365 COLOR_GREEN = 2,
366 COLOR_YELLOW = 3,
367 COLOR_BLUE = 4,
368 COLOR_MAGENTA = 5,
369 COLOR_CYAN = 6,
370 COLOR_WHITE = 7
371 };
372 #endif
373
374 static const uint32_t color_table_rgb[2][8] = {
375 { /* dark */
376 QEMU_RGB(0x00, 0x00, 0x00), /* black */
377 QEMU_RGB(0xaa, 0x00, 0x00), /* red */
378 QEMU_RGB(0x00, 0xaa, 0x00), /* green */
379 QEMU_RGB(0xaa, 0xaa, 0x00), /* yellow */
380 QEMU_RGB(0x00, 0x00, 0xaa), /* blue */
381 QEMU_RGB(0xaa, 0x00, 0xaa), /* magenta */
382 QEMU_RGB(0x00, 0xaa, 0xaa), /* cyan */
383 QEMU_RGB(0xaa, 0xaa, 0xaa), /* white */
384 },
385 { /* bright */
386 QEMU_RGB(0x00, 0x00, 0x00), /* black */
387 QEMU_RGB(0xff, 0x00, 0x00), /* red */
388 QEMU_RGB(0x00, 0xff, 0x00), /* green */
389 QEMU_RGB(0xff, 0xff, 0x00), /* yellow */
390 QEMU_RGB(0x00, 0x00, 0xff), /* blue */
391 QEMU_RGB(0xff, 0x00, 0xff), /* magenta */
392 QEMU_RGB(0x00, 0xff, 0xff), /* cyan */
393 QEMU_RGB(0xff, 0xff, 0xff), /* white */
394 }
395 };
396
397 static inline unsigned int col_expand(DisplayState *ds, unsigned int col)
398 {
399 switch(ds_get_bits_per_pixel(ds)) {
400 case 8:
401 col |= col << 8;
402 col |= col << 16;
403 break;
404 case 15:
405 case 16:
406 col |= col << 16;
407 break;
408 default:
409 break;
410 }
411
412 return col;
413 }
414 #ifdef DEBUG_CONSOLE
415 static void console_print_text_attributes(TextAttributes *t_attrib, char ch)
416 {
417 if (t_attrib->bold) {
418 printf("b");
419 } else {
420 printf(" ");
421 }
422 if (t_attrib->uline) {
423 printf("u");
424 } else {
425 printf(" ");
426 }
427 if (t_attrib->blink) {
428 printf("l");
429 } else {
430 printf(" ");
431 }
432 if (t_attrib->invers) {
433 printf("i");
434 } else {
435 printf(" ");
436 }
437 if (t_attrib->unvisible) {
438 printf("n");
439 } else {
440 printf(" ");
441 }
442
443 printf(" fg: %d bg: %d ch:'%2X' '%c'\n", t_attrib->fgcol, t_attrib->bgcol, ch, ch);
444 }
445 #endif
446
447 static void vga_putcharxy(DisplayState *ds, int x, int y, int ch,
448 TextAttributes *t_attrib)
449 {
450 uint8_t *d;
451 const uint8_t *font_ptr;
452 unsigned int font_data, linesize, xorcol, bpp;
453 int i;
454 unsigned int fgcol, bgcol;
455
456 #ifdef DEBUG_CONSOLE
457 printf("x: %2i y: %2i", x, y);
458 console_print_text_attributes(t_attrib, ch);
459 #endif
460
461 if (t_attrib->invers) {
462 bgcol = color_table[t_attrib->bold][t_attrib->fgcol];
463 fgcol = color_table[t_attrib->bold][t_attrib->bgcol];
464 } else {
465 fgcol = color_table[t_attrib->bold][t_attrib->fgcol];
466 bgcol = color_table[t_attrib->bold][t_attrib->bgcol];
467 }
468
469 bpp = (ds_get_bits_per_pixel(ds) + 7) >> 3;
470 d = ds_get_data(ds) +
471 ds_get_linesize(ds) * y * FONT_HEIGHT + bpp * x * FONT_WIDTH;
472 linesize = ds_get_linesize(ds);
473 font_ptr = vgafont16 + FONT_HEIGHT * ch;
474 xorcol = bgcol ^ fgcol;
475 switch(ds_get_bits_per_pixel(ds)) {
476 case 8:
477 for(i = 0; i < FONT_HEIGHT; i++) {
478 font_data = *font_ptr++;
479 if (t_attrib->uline
480 && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
481 font_data = 0xFF;
482 }
483 ((uint32_t *)d)[0] = (dmask16[(font_data >> 4)] & xorcol) ^ bgcol;
484 ((uint32_t *)d)[1] = (dmask16[(font_data >> 0) & 0xf] & xorcol) ^ bgcol;
485 d += linesize;
486 }
487 break;
488 case 16:
489 case 15:
490 for(i = 0; i < FONT_HEIGHT; i++) {
491 font_data = *font_ptr++;
492 if (t_attrib->uline
493 && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
494 font_data = 0xFF;
495 }
496 ((uint32_t *)d)[0] = (dmask4[(font_data >> 6)] & xorcol) ^ bgcol;
497 ((uint32_t *)d)[1] = (dmask4[(font_data >> 4) & 3] & xorcol) ^ bgcol;
498 ((uint32_t *)d)[2] = (dmask4[(font_data >> 2) & 3] & xorcol) ^ bgcol;
499 ((uint32_t *)d)[3] = (dmask4[(font_data >> 0) & 3] & xorcol) ^ bgcol;
500 d += linesize;
501 }
502 break;
503 case 32:
504 for(i = 0; i < FONT_HEIGHT; i++) {
505 font_data = *font_ptr++;
506 if (t_attrib->uline && ((i == FONT_HEIGHT - 2) || (i == FONT_HEIGHT - 3))) {
507 font_data = 0xFF;
508 }
509 ((uint32_t *)d)[0] = (-((font_data >> 7)) & xorcol) ^ bgcol;
510 ((uint32_t *)d)[1] = (-((font_data >> 6) & 1) & xorcol) ^ bgcol;
511 ((uint32_t *)d)[2] = (-((font_data >> 5) & 1) & xorcol) ^ bgcol;
512 ((uint32_t *)d)[3] = (-((font_data >> 4) & 1) & xorcol) ^ bgcol;
513 ((uint32_t *)d)[4] = (-((font_data >> 3) & 1) & xorcol) ^ bgcol;
514 ((uint32_t *)d)[5] = (-((font_data >> 2) & 1) & xorcol) ^ bgcol;
515 ((uint32_t *)d)[6] = (-((font_data >> 1) & 1) & xorcol) ^ bgcol;
516 ((uint32_t *)d)[7] = (-((font_data >> 0) & 1) & xorcol) ^ bgcol;
517 d += linesize;
518 }
519 break;
520 }
521 }
522
523 static void text_console_resize(TextConsole *s)
524 {
525 TextCell *cells, *c, *c1;
526 int w1, x, y, last_width;
527
528 last_width = s->width;
529 s->width = s->g_width / FONT_WIDTH;
530 s->height = s->g_height / FONT_HEIGHT;
531
532 w1 = last_width;
533 if (s->width < w1)
534 w1 = s->width;
535
536 cells = g_malloc(s->width * s->total_height * sizeof(TextCell));
537 for(y = 0; y < s->total_height; y++) {
538 c = &cells[y * s->width];
539 if (w1 > 0) {
540 c1 = &s->cells[y * last_width];
541 for(x = 0; x < w1; x++) {
542 *c++ = *c1++;
543 }
544 }
545 for(x = w1; x < s->width; x++) {
546 c->ch = ' ';
547 c->t_attrib = s->t_attrib_default;
548 c++;
549 }
550 }
551 g_free(s->cells);
552 s->cells = cells;
553 }
554
555 static inline void text_update_xy(TextConsole *s, int x, int y)
556 {
557 s->text_x[0] = MIN(s->text_x[0], x);
558 s->text_x[1] = MAX(s->text_x[1], x);
559 s->text_y[0] = MIN(s->text_y[0], y);
560 s->text_y[1] = MAX(s->text_y[1], y);
561 }
562
563 static void invalidate_xy(TextConsole *s, int x, int y)
564 {
565 if (s->update_x0 > x * FONT_WIDTH)
566 s->update_x0 = x * FONT_WIDTH;
567 if (s->update_y0 > y * FONT_HEIGHT)
568 s->update_y0 = y * FONT_HEIGHT;
569 if (s->update_x1 < (x + 1) * FONT_WIDTH)
570 s->update_x1 = (x + 1) * FONT_WIDTH;
571 if (s->update_y1 < (y + 1) * FONT_HEIGHT)
572 s->update_y1 = (y + 1) * FONT_HEIGHT;
573 }
574
575 static void update_xy(TextConsole *s, int x, int y)
576 {
577 TextCell *c;
578 int y1, y2;
579
580 if (s == active_console) {
581 if (!ds_get_bits_per_pixel(s->ds)) {
582 text_update_xy(s, x, y);
583 return;
584 }
585
586 y1 = (s->y_base + y) % s->total_height;
587 y2 = y1 - s->y_displayed;
588 if (y2 < 0)
589 y2 += s->total_height;
590 if (y2 < s->height) {
591 c = &s->cells[y1 * s->width + x];
592 vga_putcharxy(s->ds, x, y2, c->ch,
593 &(c->t_attrib));
594 invalidate_xy(s, x, y2);
595 }
596 }
597 }
598
599 static void console_show_cursor(TextConsole *s, int show)
600 {
601 TextCell *c;
602 int y, y1;
603
604 if (s == active_console) {
605 int x = s->x;
606
607 if (!ds_get_bits_per_pixel(s->ds)) {
608 s->cursor_invalidate = 1;
609 return;
610 }
611
612 if (x >= s->width) {
613 x = s->width - 1;
614 }
615 y1 = (s->y_base + s->y) % s->total_height;
616 y = y1 - s->y_displayed;
617 if (y < 0)
618 y += s->total_height;
619 if (y < s->height) {
620 c = &s->cells[y1 * s->width + x];
621 if (show && s->cursor_visible_phase) {
622 TextAttributes t_attrib = s->t_attrib_default;
623 t_attrib.invers = !(t_attrib.invers); /* invert fg and bg */
624 vga_putcharxy(s->ds, x, y, c->ch, &t_attrib);
625 } else {
626 vga_putcharxy(s->ds, x, y, c->ch, &(c->t_attrib));
627 }
628 invalidate_xy(s, x, y);
629 }
630 }
631 }
632
633 static void console_refresh(TextConsole *s)
634 {
635 TextCell *c;
636 int x, y, y1;
637
638 if (s != active_console)
639 return;
640 if (!ds_get_bits_per_pixel(s->ds)) {
641 s->text_x[0] = 0;
642 s->text_y[0] = 0;
643 s->text_x[1] = s->width - 1;
644 s->text_y[1] = s->height - 1;
645 s->cursor_invalidate = 1;
646 return;
647 }
648
649 vga_fill_rect(s->ds, 0, 0, ds_get_width(s->ds), ds_get_height(s->ds),
650 color_table[0][COLOR_BLACK]);
651 y1 = s->y_displayed;
652 for(y = 0; y < s->height; y++) {
653 c = s->cells + y1 * s->width;
654 for(x = 0; x < s->width; x++) {
655 vga_putcharxy(s->ds, x, y, c->ch,
656 &(c->t_attrib));
657 c++;
658 }
659 if (++y1 == s->total_height)
660 y1 = 0;
661 }
662 console_show_cursor(s, 1);
663 dpy_update(s->ds, 0, 0, ds_get_width(s->ds), ds_get_height(s->ds));
664 }
665
666 static void console_scroll(int ydelta)
667 {
668 TextConsole *s;
669 int i, y1;
670
671 s = active_console;
672 if (!s || (s->console_type == GRAPHIC_CONSOLE))
673 return;
674
675 if (ydelta > 0) {
676 for(i = 0; i < ydelta; i++) {
677 if (s->y_displayed == s->y_base)
678 break;
679 if (++s->y_displayed == s->total_height)
680 s->y_displayed = 0;
681 }
682 } else {
683 ydelta = -ydelta;
684 i = s->backscroll_height;
685 if (i > s->total_height - s->height)
686 i = s->total_height - s->height;
687 y1 = s->y_base - i;
688 if (y1 < 0)
689 y1 += s->total_height;
690 for(i = 0; i < ydelta; i++) {
691 if (s->y_displayed == y1)
692 break;
693 if (--s->y_displayed < 0)
694 s->y_displayed = s->total_height - 1;
695 }
696 }
697 console_refresh(s);
698 }
699
700 static void console_put_lf(TextConsole *s)
701 {
702 TextCell *c;
703 int x, y1;
704
705 s->y++;
706 if (s->y >= s->height) {
707 s->y = s->height - 1;
708
709 if (s->y_displayed == s->y_base) {
710 if (++s->y_displayed == s->total_height)
711 s->y_displayed = 0;
712 }
713 if (++s->y_base == s->total_height)
714 s->y_base = 0;
715 if (s->backscroll_height < s->total_height)
716 s->backscroll_height++;
717 y1 = (s->y_base + s->height - 1) % s->total_height;
718 c = &s->cells[y1 * s->width];
719 for(x = 0; x < s->width; x++) {
720 c->ch = ' ';
721 c->t_attrib = s->t_attrib_default;
722 c++;
723 }
724 if (s == active_console && s->y_displayed == s->y_base) {
725 if (!ds_get_bits_per_pixel(s->ds)) {
726 s->text_x[0] = 0;
727 s->text_y[0] = 0;
728 s->text_x[1] = s->width - 1;
729 s->text_y[1] = s->height - 1;
730 return;
731 }
732
733 vga_bitblt(s->ds, 0, FONT_HEIGHT, 0, 0,
734 s->width * FONT_WIDTH,
735 (s->height - 1) * FONT_HEIGHT);
736 vga_fill_rect(s->ds, 0, (s->height - 1) * FONT_HEIGHT,
737 s->width * FONT_WIDTH, FONT_HEIGHT,
738 color_table[0][s->t_attrib_default.bgcol]);
739 s->update_x0 = 0;
740 s->update_y0 = 0;
741 s->update_x1 = s->width * FONT_WIDTH;
742 s->update_y1 = s->height * FONT_HEIGHT;
743 }
744 }
745 }
746
747 /* Set console attributes depending on the current escape codes.
748 * NOTE: I know this code is not very efficient (checking every color for it
749 * self) but it is more readable and better maintainable.
750 */
751 static void console_handle_escape(TextConsole *s)
752 {
753 int i;
754
755 for (i=0; i<s->nb_esc_params; i++) {
756 switch (s->esc_params[i]) {
757 case 0: /* reset all console attributes to default */
758 s->t_attrib = s->t_attrib_default;
759 break;
760 case 1:
761 s->t_attrib.bold = 1;
762 break;
763 case 4:
764 s->t_attrib.uline = 1;
765 break;
766 case 5:
767 s->t_attrib.blink = 1;
768 break;
769 case 7:
770 s->t_attrib.invers = 1;
771 break;
772 case 8:
773 s->t_attrib.unvisible = 1;
774 break;
775 case 22:
776 s->t_attrib.bold = 0;
777 break;
778 case 24:
779 s->t_attrib.uline = 0;
780 break;
781 case 25:
782 s->t_attrib.blink = 0;
783 break;
784 case 27:
785 s->t_attrib.invers = 0;
786 break;
787 case 28:
788 s->t_attrib.unvisible = 0;
789 break;
790 /* set foreground color */
791 case 30:
792 s->t_attrib.fgcol=COLOR_BLACK;
793 break;
794 case 31:
795 s->t_attrib.fgcol=COLOR_RED;
796 break;
797 case 32:
798 s->t_attrib.fgcol=COLOR_GREEN;
799 break;
800 case 33:
801 s->t_attrib.fgcol=COLOR_YELLOW;
802 break;
803 case 34:
804 s->t_attrib.fgcol=COLOR_BLUE;
805 break;
806 case 35:
807 s->t_attrib.fgcol=COLOR_MAGENTA;
808 break;
809 case 36:
810 s->t_attrib.fgcol=COLOR_CYAN;
811 break;
812 case 37:
813 s->t_attrib.fgcol=COLOR_WHITE;
814 break;
815 /* set background color */
816 case 40:
817 s->t_attrib.bgcol=COLOR_BLACK;
818 break;
819 case 41:
820 s->t_attrib.bgcol=COLOR_RED;
821 break;
822 case 42:
823 s->t_attrib.bgcol=COLOR_GREEN;
824 break;
825 case 43:
826 s->t_attrib.bgcol=COLOR_YELLOW;
827 break;
828 case 44:
829 s->t_attrib.bgcol=COLOR_BLUE;
830 break;
831 case 45:
832 s->t_attrib.bgcol=COLOR_MAGENTA;
833 break;
834 case 46:
835 s->t_attrib.bgcol=COLOR_CYAN;
836 break;
837 case 47:
838 s->t_attrib.bgcol=COLOR_WHITE;
839 break;
840 }
841 }
842 }
843
844 static void console_clear_xy(TextConsole *s, int x, int y)
845 {
846 int y1 = (s->y_base + y) % s->total_height;
847 TextCell *c = &s->cells[y1 * s->width + x];
848 c->ch = ' ';
849 c->t_attrib = s->t_attrib_default;
850 update_xy(s, x, y);
851 }
852
853 static void console_putchar(TextConsole *s, int ch)
854 {
855 TextCell *c;
856 int y1, i;
857 int x, y;
858
859 switch(s->state) {
860 case TTY_STATE_NORM:
861 switch(ch) {
862 case '\r': /* carriage return */
863 s->x = 0;
864 break;
865 case '\n': /* newline */
866 console_put_lf(s);
867 break;
868 case '\b': /* backspace */
869 if (s->x > 0)
870 s->x--;
871 break;
872 case '\t': /* tabspace */
873 if (s->x + (8 - (s->x % 8)) > s->width) {
874 s->x = 0;
875 console_put_lf(s);
876 } else {
877 s->x = s->x + (8 - (s->x % 8));
878 }
879 break;
880 case '\a': /* alert aka. bell */
881 /* TODO: has to be implemented */
882 break;
883 case 14:
884 /* SI (shift in), character set 0 (ignored) */
885 break;
886 case 15:
887 /* SO (shift out), character set 1 (ignored) */
888 break;
889 case 27: /* esc (introducing an escape sequence) */
890 s->state = TTY_STATE_ESC;
891 break;
892 default:
893 if (s->x >= s->width) {
894 /* line wrap */
895 s->x = 0;
896 console_put_lf(s);
897 }
898 y1 = (s->y_base + s->y) % s->total_height;
899 c = &s->cells[y1 * s->width + s->x];
900 c->ch = ch;
901 c->t_attrib = s->t_attrib;
902 update_xy(s, s->x, s->y);
903 s->x++;
904 break;
905 }
906 break;
907 case TTY_STATE_ESC: /* check if it is a terminal escape sequence */
908 if (ch == '[') {
909 for(i=0;i<MAX_ESC_PARAMS;i++)
910 s->esc_params[i] = 0;
911 s->nb_esc_params = 0;
912 s->state = TTY_STATE_CSI;
913 } else {
914 s->state = TTY_STATE_NORM;
915 }
916 break;
917 case TTY_STATE_CSI: /* handle escape sequence parameters */
918 if (ch >= '0' && ch <= '9') {
919 if (s->nb_esc_params < MAX_ESC_PARAMS) {
920 s->esc_params[s->nb_esc_params] =
921 s->esc_params[s->nb_esc_params] * 10 + ch - '0';
922 }
923 } else {
924 s->nb_esc_params++;
925 if (ch == ';')
926 break;
927 #ifdef DEBUG_CONSOLE
928 fprintf(stderr, "escape sequence CSI%d;%d%c, %d parameters\n",
929 s->esc_params[0], s->esc_params[1], ch, s->nb_esc_params);
930 #endif
931 s->state = TTY_STATE_NORM;
932 switch(ch) {
933 case 'A':
934 /* move cursor up */
935 if (s->esc_params[0] == 0) {
936 s->esc_params[0] = 1;
937 }
938 s->y -= s->esc_params[0];
939 if (s->y < 0) {
940 s->y = 0;
941 }
942 break;
943 case 'B':
944 /* move cursor down */
945 if (s->esc_params[0] == 0) {
946 s->esc_params[0] = 1;
947 }
948 s->y += s->esc_params[0];
949 if (s->y >= s->height) {
950 s->y = s->height - 1;
951 }
952 break;
953 case 'C':
954 /* move cursor right */
955 if (s->esc_params[0] == 0) {
956 s->esc_params[0] = 1;
957 }
958 s->x += s->esc_params[0];
959 if (s->x >= s->width) {
960 s->x = s->width - 1;
961 }
962 break;
963 case 'D':
964 /* move cursor left */
965 if (s->esc_params[0] == 0) {
966 s->esc_params[0] = 1;
967 }
968 s->x -= s->esc_params[0];
969 if (s->x < 0) {
970 s->x = 0;
971 }
972 break;
973 case 'G':
974 /* move cursor to column */
975 s->x = s->esc_params[0] - 1;
976 if (s->x < 0) {
977 s->x = 0;
978 }
979 break;
980 case 'f':
981 case 'H':
982 /* move cursor to row, column */
983 s->x = s->esc_params[1] - 1;
984 if (s->x < 0) {
985 s->x = 0;
986 }
987 s->y = s->esc_params[0] - 1;
988 if (s->y < 0) {
989 s->y = 0;
990 }
991 break;
992 case 'J':
993 switch (s->esc_params[0]) {
994 case 0:
995 /* clear to end of screen */
996 for (y = s->y; y < s->height; y++) {
997 for (x = 0; x < s->width; x++) {
998 if (y == s->y && x < s->x) {
999 continue;
1000 }
1001 console_clear_xy(s, x, y);
1002 }
1003 }
1004 break;
1005 case 1:
1006 /* clear from beginning of screen */
1007 for (y = 0; y <= s->y; y++) {
1008 for (x = 0; x < s->width; x++) {
1009 if (y == s->y && x > s->x) {
1010 break;
1011 }
1012 console_clear_xy(s, x, y);
1013 }
1014 }
1015 break;
1016 case 2:
1017 /* clear entire screen */
1018 for (y = 0; y <= s->height; y++) {
1019 for (x = 0; x < s->width; x++) {
1020 console_clear_xy(s, x, y);
1021 }
1022 }
1023 break;
1024 }
1025 break;
1026 case 'K':
1027 switch (s->esc_params[0]) {
1028 case 0:
1029 /* clear to eol */
1030 for(x = s->x; x < s->width; x++) {
1031 console_clear_xy(s, x, s->y);
1032 }
1033 break;
1034 case 1:
1035 /* clear from beginning of line */
1036 for (x = 0; x <= s->x; x++) {
1037 console_clear_xy(s, x, s->y);
1038 }
1039 break;
1040 case 2:
1041 /* clear entire line */
1042 for(x = 0; x < s->width; x++) {
1043 console_clear_xy(s, x, s->y);
1044 }
1045 break;
1046 }
1047 break;
1048 case 'm':
1049 console_handle_escape(s);
1050 break;
1051 case 'n':
1052 /* report cursor position */
1053 /* TODO: send ESC[row;colR */
1054 break;
1055 case 's':
1056 /* save cursor position */
1057 s->x_saved = s->x;
1058 s->y_saved = s->y;
1059 break;
1060 case 'u':
1061 /* restore cursor position */
1062 s->x = s->x_saved;
1063 s->y = s->y_saved;
1064 break;
1065 default:
1066 #ifdef DEBUG_CONSOLE
1067 fprintf(stderr, "unhandled escape character '%c'\n", ch);
1068 #endif
1069 break;
1070 }
1071 break;
1072 }
1073 }
1074 }
1075
1076 void console_select(unsigned int index)
1077 {
1078 TextConsole *s;
1079
1080 if (index >= MAX_CONSOLES)
1081 return;
1082 if (active_console) {
1083 active_console->g_width = ds_get_width(active_console->ds);
1084 active_console->g_height = ds_get_height(active_console->ds);
1085 }
1086 s = consoles[index];
1087 if (s) {
1088 DisplayState *ds = s->ds;
1089
1090 if (active_console->cursor_timer) {
1091 qemu_del_timer(active_console->cursor_timer);
1092 }
1093 active_console = s;
1094 if (ds_get_bits_per_pixel(s->ds)) {
1095 ds->surface = qemu_resize_displaysurface(ds, s->g_width, s->g_height);
1096 } else {
1097 s->ds->surface->width = s->width;
1098 s->ds->surface->height = s->height;
1099 }
1100 if (s->cursor_timer) {
1101 qemu_mod_timer(s->cursor_timer,
1102 qemu_get_clock_ms(rt_clock) + CONSOLE_CURSOR_PERIOD / 2);
1103 }
1104 dpy_resize(s->ds);
1105 vga_hw_invalidate();
1106 }
1107 }
1108
1109 static int console_puts(CharDriverState *chr, const uint8_t *buf, int len)
1110 {
1111 TextConsole *s = chr->opaque;
1112 int i;
1113
1114 s->update_x0 = s->width * FONT_WIDTH;
1115 s->update_y0 = s->height * FONT_HEIGHT;
1116 s->update_x1 = 0;
1117 s->update_y1 = 0;
1118 console_show_cursor(s, 0);
1119 for(i = 0; i < len; i++) {
1120 console_putchar(s, buf[i]);
1121 }
1122 console_show_cursor(s, 1);
1123 if (ds_get_bits_per_pixel(s->ds) && s->update_x0 < s->update_x1) {
1124 dpy_update(s->ds, s->update_x0, s->update_y0,
1125 s->update_x1 - s->update_x0,
1126 s->update_y1 - s->update_y0);
1127 }
1128 return len;
1129 }
1130
1131 static void kbd_send_chars(void *opaque)
1132 {
1133 TextConsole *s = opaque;
1134 int len;
1135 uint8_t buf[16];
1136
1137 len = qemu_chr_be_can_write(s->chr);
1138 if (len > s->out_fifo.count)
1139 len = s->out_fifo.count;
1140 if (len > 0) {
1141 if (len > sizeof(buf))
1142 len = sizeof(buf);
1143 qemu_fifo_read(&s->out_fifo, buf, len);
1144 qemu_chr_be_write(s->chr, buf, len);
1145 }
1146 /* characters are pending: we send them a bit later (XXX:
1147 horrible, should change char device API) */
1148 if (s->out_fifo.count > 0) {
1149 qemu_mod_timer(s->kbd_timer, qemu_get_clock_ms(rt_clock) + 1);
1150 }
1151 }
1152
1153 /* called when an ascii key is pressed */
1154 void kbd_put_keysym(int keysym)
1155 {
1156 TextConsole *s;
1157 uint8_t buf[16], *q;
1158 int c;
1159
1160 s = active_console;
1161 if (!s || (s->console_type == GRAPHIC_CONSOLE))
1162 return;
1163
1164 switch(keysym) {
1165 case QEMU_KEY_CTRL_UP:
1166 console_scroll(-1);
1167 break;
1168 case QEMU_KEY_CTRL_DOWN:
1169 console_scroll(1);
1170 break;
1171 case QEMU_KEY_CTRL_PAGEUP:
1172 console_scroll(-10);
1173 break;
1174 case QEMU_KEY_CTRL_PAGEDOWN:
1175 console_scroll(10);
1176 break;
1177 default:
1178 /* convert the QEMU keysym to VT100 key string */
1179 q = buf;
1180 if (keysym >= 0xe100 && keysym <= 0xe11f) {
1181 *q++ = '\033';
1182 *q++ = '[';
1183 c = keysym - 0xe100;
1184 if (c >= 10)
1185 *q++ = '0' + (c / 10);
1186 *q++ = '0' + (c % 10);
1187 *q++ = '~';
1188 } else if (keysym >= 0xe120 && keysym <= 0xe17f) {
1189 *q++ = '\033';
1190 *q++ = '[';
1191 *q++ = keysym & 0xff;
1192 } else if (s->echo && (keysym == '\r' || keysym == '\n')) {
1193 console_puts(s->chr, (const uint8_t *) "\r", 1);
1194 *q++ = '\n';
1195 } else {
1196 *q++ = keysym;
1197 }
1198 if (s->echo) {
1199 console_puts(s->chr, buf, q - buf);
1200 }
1201 if (s->chr->chr_read) {
1202 qemu_fifo_write(&s->out_fifo, buf, q - buf);
1203 kbd_send_chars(s);
1204 }
1205 break;
1206 }
1207 }
1208
1209 static void text_console_invalidate(void *opaque)
1210 {
1211 TextConsole *s = (TextConsole *) opaque;
1212 if (!ds_get_bits_per_pixel(s->ds) && s->console_type == TEXT_CONSOLE) {
1213 s->g_width = ds_get_width(s->ds);
1214 s->g_height = ds_get_height(s->ds);
1215 text_console_resize(s);
1216 }
1217 console_refresh(s);
1218 }
1219
1220 static void text_console_update(void *opaque, console_ch_t *chardata)
1221 {
1222 TextConsole *s = (TextConsole *) opaque;
1223 int i, j, src;
1224
1225 if (s->text_x[0] <= s->text_x[1]) {
1226 src = (s->y_base + s->text_y[0]) * s->width;
1227 chardata += s->text_y[0] * s->width;
1228 for (i = s->text_y[0]; i <= s->text_y[1]; i ++)
1229 for (j = 0; j < s->width; j ++, src ++)
1230 console_write_ch(chardata ++, s->cells[src].ch |
1231 (s->cells[src].t_attrib.fgcol << 12) |
1232 (s->cells[src].t_attrib.bgcol << 8) |
1233 (s->cells[src].t_attrib.bold << 21));
1234 dpy_update(s->ds, s->text_x[0], s->text_y[0],
1235 s->text_x[1] - s->text_x[0], i - s->text_y[0]);
1236 s->text_x[0] = s->width;
1237 s->text_y[0] = s->height;
1238 s->text_x[1] = 0;
1239 s->text_y[1] = 0;
1240 }
1241 if (s->cursor_invalidate) {
1242 dpy_cursor(s->ds, s->x, s->y);
1243 s->cursor_invalidate = 0;
1244 }
1245 }
1246
1247 static TextConsole *get_graphic_console(DisplayState *ds)
1248 {
1249 int i;
1250 TextConsole *s;
1251 for (i = 0; i < nb_consoles; i++) {
1252 s = consoles[i];
1253 if (s->console_type == GRAPHIC_CONSOLE && s->ds == ds)
1254 return s;
1255 }
1256 return NULL;
1257 }
1258
1259 static TextConsole *new_console(DisplayState *ds, console_type_t console_type)
1260 {
1261 TextConsole *s;
1262 int i;
1263
1264 if (nb_consoles >= MAX_CONSOLES)
1265 return NULL;
1266 s = g_malloc0(sizeof(TextConsole));
1267 if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) &&
1268 (console_type == GRAPHIC_CONSOLE))) {
1269 active_console = s;
1270 }
1271 s->ds = ds;
1272 s->console_type = console_type;
1273 if (console_type != GRAPHIC_CONSOLE) {
1274 s->index = nb_consoles;
1275 consoles[nb_consoles++] = s;
1276 } else {
1277 /* HACK: Put graphical consoles before text consoles. */
1278 for (i = nb_consoles; i > 0; i--) {
1279 if (consoles[i - 1]->console_type == GRAPHIC_CONSOLE)
1280 break;
1281 consoles[i] = consoles[i - 1];
1282 consoles[i]->index = i;
1283 }
1284 s->index = i;
1285 consoles[i] = s;
1286 nb_consoles++;
1287 }
1288 return s;
1289 }
1290
1291 static DisplaySurface* defaultallocator_create_displaysurface(int width, int height)
1292 {
1293 DisplaySurface *surface = (DisplaySurface*) g_malloc0(sizeof(DisplaySurface));
1294
1295 int linesize = width * 4;
1296 qemu_alloc_display(surface, width, height, linesize,
1297 qemu_default_pixelformat(32), 0);
1298 return surface;
1299 }
1300
1301 static DisplaySurface* defaultallocator_resize_displaysurface(DisplaySurface *surface,
1302 int width, int height)
1303 {
1304 int linesize = width * 4;
1305 qemu_alloc_display(surface, width, height, linesize,
1306 qemu_default_pixelformat(32), 0);
1307 return surface;
1308 }
1309
1310 void qemu_alloc_display(DisplaySurface *surface, int width, int height,
1311 int linesize, PixelFormat pf, int newflags)
1312 {
1313 void *data;
1314 surface->width = width;
1315 surface->height = height;
1316 surface->linesize = linesize;
1317 surface->pf = pf;
1318 if (surface->flags & QEMU_ALLOCATED_FLAG) {
1319 data = g_realloc(surface->data,
1320 surface->linesize * surface->height);
1321 } else {
1322 data = g_malloc(surface->linesize * surface->height);
1323 }
1324 surface->data = (uint8_t *)data;
1325 surface->flags = newflags | QEMU_ALLOCATED_FLAG;
1326 #ifdef HOST_WORDS_BIGENDIAN
1327 surface->flags |= QEMU_BIG_ENDIAN_FLAG;
1328 #endif
1329 }
1330
1331 DisplaySurface* qemu_create_displaysurface_from(int width, int height, int bpp,
1332 int linesize, uint8_t *data)
1333 {
1334 DisplaySurface *surface = (DisplaySurface*) g_malloc0(sizeof(DisplaySurface));
1335
1336 surface->width = width;
1337 surface->height = height;
1338 surface->linesize = linesize;
1339 surface->pf = qemu_default_pixelformat(bpp);
1340 #ifdef HOST_WORDS_BIGENDIAN
1341 surface->flags = QEMU_BIG_ENDIAN_FLAG;
1342 #endif
1343 surface->data = data;
1344
1345 return surface;
1346 }
1347
1348 static void defaultallocator_free_displaysurface(DisplaySurface *surface)
1349 {
1350 if (surface == NULL)
1351 return;
1352 if (surface->flags & QEMU_ALLOCATED_FLAG)
1353 g_free(surface->data);
1354 g_free(surface);
1355 }
1356
1357 static struct DisplayAllocator default_allocator = {
1358 defaultallocator_create_displaysurface,
1359 defaultallocator_resize_displaysurface,
1360 defaultallocator_free_displaysurface
1361 };
1362
1363 static void dumb_display_init(void)
1364 {
1365 DisplayState *ds = g_malloc0(sizeof(DisplayState));
1366 int width = 640;
1367 int height = 480;
1368
1369 ds->allocator = &default_allocator;
1370 if (is_fixedsize_console()) {
1371 width = active_console->g_width;
1372 height = active_console->g_height;
1373 }
1374 ds->surface = qemu_create_displaysurface(ds, width, height);
1375 register_displaystate(ds);
1376 }
1377
1378 /***********************************************************/
1379 /* register display */
1380
1381 void register_displaystate(DisplayState *ds)
1382 {
1383 DisplayState **s;
1384 s = &display_state;
1385 while (*s != NULL)
1386 s = &(*s)->next;
1387 ds->next = NULL;
1388 *s = ds;
1389 }
1390
1391 DisplayState *get_displaystate(void)
1392 {
1393 if (!display_state) {
1394 dumb_display_init ();
1395 }
1396 return display_state;
1397 }
1398
1399 DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da)
1400 {
1401 if(ds->allocator == &default_allocator) {
1402 DisplaySurface *surf;
1403 surf = da->create_displaysurface(ds_get_width(ds), ds_get_height(ds));
1404 defaultallocator_free_displaysurface(ds->surface);
1405 ds->surface = surf;
1406 ds->allocator = da;
1407 }
1408 return ds->allocator;
1409 }
1410
1411 DisplayState *graphic_console_init(vga_hw_update_ptr update,
1412 vga_hw_invalidate_ptr invalidate,
1413 vga_hw_screen_dump_ptr screen_dump,
1414 vga_hw_text_update_ptr text_update,
1415 void *opaque)
1416 {
1417 TextConsole *s;
1418 DisplayState *ds;
1419
1420 ds = (DisplayState *) g_malloc0(sizeof(DisplayState));
1421 ds->allocator = &default_allocator;
1422 ds->surface = qemu_create_displaysurface(ds, 640, 480);
1423
1424 s = new_console(ds, GRAPHIC_CONSOLE);
1425 if (s == NULL) {
1426 qemu_free_displaysurface(ds);
1427 g_free(ds);
1428 return NULL;
1429 }
1430 s->hw_update = update;
1431 s->hw_invalidate = invalidate;
1432 s->hw_screen_dump = screen_dump;
1433 s->hw_text_update = text_update;
1434 s->hw = opaque;
1435
1436 register_displaystate(ds);
1437 return ds;
1438 }
1439
1440 int is_graphic_console(void)
1441 {
1442 return active_console && active_console->console_type == GRAPHIC_CONSOLE;
1443 }
1444
1445 int is_fixedsize_console(void)
1446 {
1447 return active_console && active_console->console_type != TEXT_CONSOLE;
1448 }
1449
1450 void console_color_init(DisplayState *ds)
1451 {
1452 int i, j;
1453 for (j = 0; j < 2; j++) {
1454 for (i = 0; i < 8; i++) {
1455 color_table[j][i] = col_expand(ds,
1456 vga_get_color(ds, color_table_rgb[j][i]));
1457 }
1458 }
1459 }
1460
1461 static void text_console_set_echo(CharDriverState *chr, bool echo)
1462 {
1463 TextConsole *s = chr->opaque;
1464
1465 s->echo = echo;
1466 }
1467
1468 static void text_console_update_cursor(void *opaque)
1469 {
1470 TextConsole *s = opaque;
1471
1472 s->cursor_visible_phase = !s->cursor_visible_phase;
1473 vga_hw_invalidate();
1474 qemu_mod_timer(s->cursor_timer,
1475 qemu_get_clock_ms(rt_clock) + CONSOLE_CURSOR_PERIOD / 2);
1476 }
1477
1478 static void text_console_do_init(CharDriverState *chr, DisplayState *ds)
1479 {
1480 TextConsole *s;
1481 static int color_inited;
1482
1483 s = chr->opaque;
1484
1485 chr->chr_write = console_puts;
1486
1487 s->out_fifo.buf = s->out_fifo_buf;
1488 s->out_fifo.buf_size = sizeof(s->out_fifo_buf);
1489 s->kbd_timer = qemu_new_timer_ms(rt_clock, kbd_send_chars, s);
1490 s->ds = ds;
1491
1492 if (!color_inited) {
1493 color_inited = 1;
1494 console_color_init(s->ds);
1495 }
1496 s->y_displayed = 0;
1497 s->y_base = 0;
1498 s->total_height = DEFAULT_BACKSCROLL;
1499 s->x = 0;
1500 s->y = 0;
1501 if (s->console_type == TEXT_CONSOLE) {
1502 s->g_width = ds_get_width(s->ds);
1503 s->g_height = ds_get_height(s->ds);
1504 }
1505
1506 s->cursor_timer =
1507 qemu_new_timer_ms(rt_clock, text_console_update_cursor, s);
1508
1509 s->hw_invalidate = text_console_invalidate;
1510 s->hw_text_update = text_console_update;
1511 s->hw = s;
1512
1513 /* Set text attribute defaults */
1514 s->t_attrib_default.bold = 0;
1515 s->t_attrib_default.uline = 0;
1516 s->t_attrib_default.blink = 0;
1517 s->t_attrib_default.invers = 0;
1518 s->t_attrib_default.unvisible = 0;
1519 s->t_attrib_default.fgcol = COLOR_WHITE;
1520 s->t_attrib_default.bgcol = COLOR_BLACK;
1521 /* set current text attributes to default */
1522 s->t_attrib = s->t_attrib_default;
1523 text_console_resize(s);
1524
1525 if (chr->label) {
1526 char msg[128];
1527 int len;
1528
1529 s->t_attrib.bgcol = COLOR_BLUE;
1530 len = snprintf(msg, sizeof(msg), "%s console\r\n", chr->label);
1531 console_puts(chr, (uint8_t*)msg, len);
1532 s->t_attrib = s->t_attrib_default;
1533 }
1534
1535 qemu_chr_generic_open(chr);
1536 if (chr->init)
1537 chr->init(chr);
1538 }
1539
1540 CharDriverState *text_console_init(QemuOpts *opts)
1541 {
1542 CharDriverState *chr;
1543 TextConsole *s;
1544 unsigned width;
1545 unsigned height;
1546
1547 chr = g_malloc0(sizeof(CharDriverState));
1548
1549 width = qemu_opt_get_number(opts, "width", 0);
1550 if (width == 0)
1551 width = qemu_opt_get_number(opts, "cols", 0) * FONT_WIDTH;
1552
1553 height = qemu_opt_get_number(opts, "height", 0);
1554 if (height == 0)
1555 height = qemu_opt_get_number(opts, "rows", 0) * FONT_HEIGHT;
1556
1557 if (width == 0 || height == 0) {
1558 s = new_console(NULL, TEXT_CONSOLE);
1559 } else {
1560 s = new_console(NULL, TEXT_CONSOLE_FIXED_SIZE);
1561 }
1562
1563 if (!s) {
1564 g_free(chr);
1565 return NULL;
1566 }
1567
1568 s->chr = chr;
1569 s->g_width = width;
1570 s->g_height = height;
1571 chr->opaque = s;
1572 chr->chr_set_echo = text_console_set_echo;
1573 return chr;
1574 }
1575
1576 void text_consoles_set_display(DisplayState *ds)
1577 {
1578 int i;
1579
1580 for (i = 0; i < nb_consoles; i++) {
1581 if (consoles[i]->console_type != GRAPHIC_CONSOLE) {
1582 text_console_do_init(consoles[i]->chr, ds);
1583 }
1584 }
1585 }
1586
1587 void qemu_console_resize(DisplayState *ds, int width, int height)
1588 {
1589 TextConsole *s = get_graphic_console(ds);
1590 if (!s) return;
1591
1592 s->g_width = width;
1593 s->g_height = height;
1594 if (is_graphic_console()) {
1595 ds->surface = qemu_resize_displaysurface(ds, width, height);
1596 dpy_resize(ds);
1597 }
1598 }
1599
1600 void qemu_console_copy(DisplayState *ds, int src_x, int src_y,
1601 int dst_x, int dst_y, int w, int h)
1602 {
1603 if (is_graphic_console()) {
1604 dpy_copy(ds, src_x, src_y, dst_x, dst_y, w, h);
1605 }
1606 }
1607
1608 PixelFormat qemu_different_endianness_pixelformat(int bpp)
1609 {
1610 PixelFormat pf;
1611
1612 memset(&pf, 0x00, sizeof(PixelFormat));
1613
1614 pf.bits_per_pixel = bpp;
1615 pf.bytes_per_pixel = bpp / 8;
1616 pf.depth = bpp == 32 ? 24 : bpp;
1617
1618 switch (bpp) {
1619 case 24:
1620 pf.rmask = 0x000000FF;
1621 pf.gmask = 0x0000FF00;
1622 pf.bmask = 0x00FF0000;
1623 pf.rmax = 255;
1624 pf.gmax = 255;
1625 pf.bmax = 255;
1626 pf.rshift = 0;
1627 pf.gshift = 8;
1628 pf.bshift = 16;
1629 pf.rbits = 8;
1630 pf.gbits = 8;
1631 pf.bbits = 8;
1632 break;
1633 case 32:
1634 pf.rmask = 0x0000FF00;
1635 pf.gmask = 0x00FF0000;
1636 pf.bmask = 0xFF000000;
1637 pf.amask = 0x00000000;
1638 pf.amax = 255;
1639 pf.rmax = 255;
1640 pf.gmax = 255;
1641 pf.bmax = 255;
1642 pf.ashift = 0;
1643 pf.rshift = 8;
1644 pf.gshift = 16;
1645 pf.bshift = 24;
1646 pf.rbits = 8;
1647 pf.gbits = 8;
1648 pf.bbits = 8;
1649 pf.abits = 8;
1650 break;
1651 default:
1652 break;
1653 }
1654 return pf;
1655 }
1656
1657 PixelFormat qemu_default_pixelformat(int bpp)
1658 {
1659 PixelFormat pf;
1660
1661 memset(&pf, 0x00, sizeof(PixelFormat));
1662
1663 pf.bits_per_pixel = bpp;
1664 pf.bytes_per_pixel = bpp / 8;
1665 pf.depth = bpp == 32 ? 24 : bpp;
1666
1667 switch (bpp) {
1668 case 15:
1669 pf.bits_per_pixel = 16;
1670 pf.bytes_per_pixel = 2;
1671 pf.rmask = 0x00007c00;
1672 pf.gmask = 0x000003E0;
1673 pf.bmask = 0x0000001F;
1674 pf.rmax = 31;
1675 pf.gmax = 31;
1676 pf.bmax = 31;
1677 pf.rshift = 10;
1678 pf.gshift = 5;
1679 pf.bshift = 0;
1680 pf.rbits = 5;
1681 pf.gbits = 5;
1682 pf.bbits = 5;
1683 break;
1684 case 16:
1685 pf.rmask = 0x0000F800;
1686 pf.gmask = 0x000007E0;
1687 pf.bmask = 0x0000001F;
1688 pf.rmax = 31;
1689 pf.gmax = 63;
1690 pf.bmax = 31;
1691 pf.rshift = 11;
1692 pf.gshift = 5;
1693 pf.bshift = 0;
1694 pf.rbits = 5;
1695 pf.gbits = 6;
1696 pf.bbits = 5;
1697 break;
1698 case 24:
1699 pf.rmask = 0x00FF0000;
1700 pf.gmask = 0x0000FF00;
1701 pf.bmask = 0x000000FF;
1702 pf.rmax = 255;
1703 pf.gmax = 255;
1704 pf.bmax = 255;
1705 pf.rshift = 16;
1706 pf.gshift = 8;
1707 pf.bshift = 0;
1708 pf.rbits = 8;
1709 pf.gbits = 8;
1710 pf.bbits = 8;
1711 break;
1712 case 32:
1713 pf.rmask = 0x00FF0000;
1714 pf.gmask = 0x0000FF00;
1715 pf.bmask = 0x000000FF;
1716 pf.amax = 255;
1717 pf.rmax = 255;
1718 pf.gmax = 255;
1719 pf.bmax = 255;
1720 pf.ashift = 24;
1721 pf.rshift = 16;
1722 pf.gshift = 8;
1723 pf.bshift = 0;
1724 pf.rbits = 8;
1725 pf.gbits = 8;
1726 pf.bbits = 8;
1727 pf.abits = 8;
1728 break;
1729 default:
1730 break;
1731 }
1732 return pf;
1733 }
QEmu