console.c

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